{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "指定caffe的根路径"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this file should be run from {caffe_root}/examples (otherwise change this line)\n",
    "caffe_root = '/home/wang/Desktop/caffe-1.0'  \n",
    "\n",
    "import sys\n",
    "sys.path.insert(0, caffe_root + 'python')\n",
    "import caffe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 下载mnist数据集\n",
    "- 制作lmdb数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading...\n",
      "Creating lmdb...\n",
      "I0805 19:53:02.762653 23829 db_lmdb.cpp:35] Opened lmdb examples/mnist/mnist_train_lmdb\n",
      "I0805 19:53:02.763011 23829 convert_mnist_data.cpp:88] A total of 60000 items.\n",
      "I0805 19:53:02.763026 23829 convert_mnist_data.cpp:89] Rows: 28 Cols: 28\n",
      "I0805 19:53:03.026511 23829 convert_mnist_data.cpp:108] Processed 60000 files.\n",
      "I0805 19:53:03.091770 23831 db_lmdb.cpp:35] Opened lmdb examples/mnist/mnist_test_lmdb\n",
      "I0805 19:53:03.092027 23831 convert_mnist_data.cpp:88] A total of 10000 items.\n",
      "I0805 19:53:03.092036 23831 convert_mnist_data.cpp:89] Rows: 28 Cols: 28\n",
      "I0805 19:53:03.140372 23831 convert_mnist_data.cpp:108] Processed 10000 files.\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "# run scripts from caffe root\n",
    "import os\n",
    "os.chdir(caffe_root)\n",
    "# Download data\n",
    "!data/mnist/get_mnist.sh\n",
    "# Prepare data\n",
    "!examples/mnist/create_mnist.sh\n",
    "# back to examples\n",
    "os.chdir('examples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from caffe import layers as L, params as P\n",
    "\n",
    "def lenet(lmdb, batch_size):\n",
    "    # our version of LeNet: a series of linear and simple nonlinear transformations\n",
    "    # 制作一个caffe网络\n",
    "    n = caffe.NetSpec()\n",
    "    # 指定网络的数据源\n",
    "    n.data, n.label = L.Data(batch_size=batch_size, backend=P.Data.LMDB, source=lmdb,\n",
    "                             transform_param=dict(scale=1./255), ntop=2)\n",
    "    # 指定卷积层\n",
    "    n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, weight_filler=dict(type='xavier'))\n",
    "    # 指定池化层\n",
    "    n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n",
    "    # 指定卷积层\n",
    "    n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, weight_filler=dict(type='xavier'))\n",
    "    # 指定池化层\n",
    "    n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n",
    "    # 指定全连接层\n",
    "    n.fc1 =   L.InnerProduct(n.pool2, num_output=500, weight_filler=dict(type='xavier'))\n",
    "    # 指定激活层\n",
    "    n.relu1 = L.ReLU(n.fc1, in_place=True)\n",
    "    # 激活后再跟一个全连接层（全连接层就的是一个dense？我理解是多层感知机，其实就是算內积，获得一个结果），计算score，用于loss优化\n",
    "    n.score = L.InnerProduct(n.relu1, num_output=10, weight_filler=dict(type='xavier'))\n",
    "    # 指定损失层（损失层只要在训练模型的时候才有用）\n",
    "    n.loss =  L.SoftmaxWithLoss(n.score, n.label)\n",
    "    # 返回神经网络\n",
    "    return n.to_proto()\n",
    "    \n",
    "# 保存训练神经网络\n",
    "with open('mnist/lenet_auto_train.prototxt', 'w') as f:\n",
    "    f.write(str(lenet('mnist/mnist_train_lmdb', 64)))\n",
    "# 保存测试神经网络（这里我有个疑问？测试神经网络怎么和训练网络是一个样呢？？）\n",
    "with open('mnist/lenet_auto_test.prototxt', 'w') as f:\n",
    "    f.write(str(lenet('mnist/mnist_test_lmdb', 100)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer {\r\n",
      "  name: \"data\"\r\n",
      "  type: \"Data\"\r\n",
      "  top: \"data\"\r\n",
      "  top: \"label\"\r\n",
      "  transform_param {\r\n",
      "    scale: 0.00392156885937\r\n",
      "  }\r\n",
      "  data_param {\r\n",
      "    source: \"mnist/mnist_train_lmdb\"\r\n",
      "    batch_size: 64\r\n",
      "    backend: LMDB\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"conv1\"\r\n",
      "  type: \"Convolution\"\r\n",
      "  bottom: \"data\"\r\n",
      "  top: \"conv1\"\r\n",
      "  convolution_param {\r\n",
      "    num_output: 20\r\n",
      "    kernel_size: 5\r\n",
      "    weight_filler {\r\n",
      "      type: \"xavier\"\r\n",
      "    }\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"pool1\"\r\n",
      "  type: \"Pooling\"\r\n",
      "  bottom: \"conv1\"\r\n",
      "  top: \"pool1\"\r\n",
      "  pooling_param {\r\n",
      "    pool: MAX\r\n",
      "    kernel_size: 2\r\n",
      "    stride: 2\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"conv2\"\r\n",
      "  type: \"Convolution\"\r\n",
      "  bottom: \"pool1\"\r\n",
      "  top: \"conv2\"\r\n",
      "  convolution_param {\r\n",
      "    num_output: 50\r\n",
      "    kernel_size: 5\r\n",
      "    weight_filler {\r\n",
      "      type: \"xavier\"\r\n",
      "    }\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"pool2\"\r\n",
      "  type: \"Pooling\"\r\n",
      "  bottom: \"conv2\"\r\n",
      "  top: \"pool2\"\r\n",
      "  pooling_param {\r\n",
      "    pool: MAX\r\n",
      "    kernel_size: 2\r\n",
      "    stride: 2\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"fc1\"\r\n",
      "  type: \"InnerProduct\"\r\n",
      "  bottom: \"pool2\"\r\n",
      "  top: \"fc1\"\r\n",
      "  inner_product_param {\r\n",
      "    num_output: 500\r\n",
      "    weight_filler {\r\n",
      "      type: \"xavier\"\r\n",
      "    }\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"relu1\"\r\n",
      "  type: \"ReLU\"\r\n",
      "  bottom: \"fc1\"\r\n",
      "  top: \"fc1\"\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"score\"\r\n",
      "  type: \"InnerProduct\"\r\n",
      "  bottom: \"fc1\"\r\n",
      "  top: \"score\"\r\n",
      "  inner_product_param {\r\n",
      "    num_output: 10\r\n",
      "    weight_filler {\r\n",
      "      type: \"xavier\"\r\n",
      "    }\r\n",
      "  }\r\n",
      "}\r\n",
      "layer {\r\n",
      "  name: \"loss\"\r\n",
      "  type: \"SoftmaxWithLoss\"\r\n",
      "  bottom: \"score\"\r\n",
      "  bottom: \"label\"\r\n",
      "  top: \"loss\"\r\n",
      "}\r\n"
     ]
    }
   ],
   "source": [
    "!cat mnist/lenet_auto_train.prototxt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# The train/test net protocol buffer definition\r\n",
      "train_net: \"mnist/lenet_auto_train.prototxt\"\r\n",
      "test_net: \"mnist/lenet_auto_test.prototxt\"\r\n",
      "# test_iter specifies how many forward passes the test should carry out.\r\n",
      "# In the case of MNIST, we have test batch size 100 and 100 test iterations,\r\n",
      "# covering the full 10,000 testing images.\r\n",
      "test_iter: 100\r\n",
      "# Carry out testing every 500 training iterations.\r\n",
      "test_interval: 500\r\n",
      "# The base learning rate, momentum and the weight decay of the network.\r\n",
      "base_lr: 0.01\r\n",
      "momentum: 0.9\r\n",
      "weight_decay: 0.0005\r\n",
      "# The learning rate policy\r\n",
      "lr_policy: \"inv\"\r\n",
      "gamma: 0.0001\r\n",
      "power: 0.75\r\n",
      "# Display every 100 iterations\r\n",
      "display: 100\r\n",
      "# The maximum number of iterations\r\n",
      "max_iter: 10000\r\n",
      "# snapshot intermediate results\r\n",
      "snapshot: 5000\r\n",
      "snapshot_prefix: \"mnist/lenet\"\r\n",
      "solver_mode: CPU\r\n"
     ]
    }
   ],
   "source": [
    "!cat mnist/lenet_auto_solver.prototxt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如果用cpu模式，这里一定要注释掉\n",
    "# caffe.set_device(0)\n",
    "# 选用cpu模式（暂时没有gpu呢）\n",
    "caffe.set_mode_cpu()\n",
    "\n",
    "### load the solver and create train and test nets\n",
    "solver = None  # ignore this workaround for lmdb data (can't instantiate two solvers on the same data)\n",
    "# 使用SGD的solver进行，加载solver配置\n",
    "solver = caffe.SGDSolver('mnist/lenet_auto_solver.prototxt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('data', (64, 1, 28, 28)),\n",
       " ('label', (64,)),\n",
       " ('conv1', (64, 20, 24, 24)),\n",
       " ('pool1', (64, 20, 12, 12)),\n",
       " ('conv2', (64, 50, 8, 8)),\n",
       " ('pool2', (64, 50, 4, 4)),\n",
       " ('fc1', (64, 500)),\n",
       " ('score', (64, 10)),\n",
       " ('loss', ())]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each output is (batch size, feature dim, spatial dim)\n",
    "# 打印一下神经网络每一层的数据接口维度（blob）\n",
    "# data： 64个batch_size，1个通道，weight和height都是28\n",
    "# label： batch_size 64\n",
    "# 卷积层： batch_size 64，后面的不太清楚？？\n",
    "# 池化层： batch_size 64，后面的不太清楚？？\n",
    "# fc全连接层：batch_size 64， 输出500\n",
    "# score层：batch_size 64，输出10维\n",
    "[(k, v.data.shape) for k, v in solver.net.blobs.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('conv1', (20, 1, 5, 5)),\n",
       " ('conv2', (50, 20, 5, 5)),\n",
       " ('fc1', (500, 800)),\n",
       " ('score', (10, 500))]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# just print the weight sizes (we'll omit the biases)\n",
    "# 打印每一层的网络参数\n",
    "# 卷积层的参数，前两个不太了解，后两个应该是卷积核大小\n",
    "# 全连接参数应该是：输出，输入\n",
    "# score层参数： 输出，输入\n",
    "[(k, v[0].data.shape) for k, v in solver.net.params.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': array(2.3174193, dtype=float32)}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 执行者向前移动一层（拿数据）\n",
    "solver.net.forward()  # train net\n",
    "# 测试网络前向移动一层（拿数据）\n",
    "solver.test_nets[0].forward()  # test net (there can be more than one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train labels: [5. 0. 4. 1. 9. 2. 1. 3.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2826fe90>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we use a little trick to tile the first eight images\n",
    "# 从blob里面拿到data的前8个数据，并且reshape成为原有图片的格式，颜色使用灰色，进行画图\n",
    "plt.imshow(solver.net.blobs['data'].data[:8, 0].transpose(1, 0, 2).reshape(28, 8*28), cmap='gray')\n",
    "# 去掉画图的标尺（说白就是为了好看）\n",
    "plt.axis('off')\n",
    "# 打印对应的label\n",
    "print 'train labels:', solver.net.blobs['label'].data[:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test labels: [7. 2. 1. 0. 4. 1. 4. 9.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf208e5b90>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 打印测试集数据\n",
    "plt.imshow(solver.test_nets[0].blobs['data'].data[:8, 0].transpose(1, 0, 2).reshape(28, 8*28), cmap='gray')\n",
    "plt.axis('off')\n",
    "print 'test labels:', solver.test_nets[0].blobs['label'].data[:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 执行者训练一次神经网络\n",
    "solver.step(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 24.5, 19.5, -0.5)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT8AAAD8CAYAAAABraMFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAC6pJREFUeJzt3c1uVvXXBuD9QAulQMtHKyBQQBpiDGqMM4OJUU/FREeegVMHno9TPQBj1BjBTyAIlLZYKdAWWtr/AfgO7pVAaN51XeM7P/bz7N2bPXhW1mhnZ2cA6GbPy74AgJdB+QEtKT+gJeUHtKT8gJaUH9CS8gNaUn5AS8oPaGnsZV/A/+Wrr76Kx07u3bsXn7u2thZnL126FOVOnz4dn/nZZ5/F2ZMnT8bZra2tOHvkyJE4Ozk5GWc/+OCDOHvixIk4++zZs+eaG4ZhuH79epy9evVqnN3c3Iyzt2/fjrOLi4txds+e/H3mk08+iXKHDx+Oz7x7926cXVhYiLOPHj2Ks19//fUoyXnzA1pSfkBLyg9oSfkBLSk/oCXlB7Sk/ICWlB/QkvIDWlJ+QEu7crytMn708OHDOFsZGUvHwM6fPx+feebMmTg7OzsbZw8cOBBnJyYm4uzYWP54VK5he3s7zqbjWqNRNNE0DMMwXLhwIc5+8803cfb48eNx9tChQ3G2MrL24MGD534N4+Pj8Znr6+txtnLPKteQ8uYHtKT8gJaUH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlnbleNvq6mqcrYxKVbZQpaNwlW1ox44di7OVkabK9rbKGFplG9nOTrxwb3j8+HGcTcfx5ubm4jOnp6fj7KlTp+LsuXPn4mzlPty5cyfOrqysPPdrqNyvmzdvxtnK81V5xlPe/ICWlB/QkvIDWlJ+QEvKD2hJ+QEtKT+gJeUHtKT8gJaUH9DSrhxvq4ysVTZmVUbR0mxlC9drr70WZyvfQWWzVWWs6tGjR3F2Y2MjzlY2yKVjhvPz8/GZz549i7Pvv/9+nL1y5UqcrWworIw6VkYo9+7dG+UWFxfjM0+fPh1n9+3bF2cr9yzlzQ9oSfkBLSk/oCXlB7Sk/ICWlB/QkvIDWlJ+QEvKD2hJ+QEt7crxtosXL8bZylhTZbwt3cRV2aw1OzsbZ0ejUZytfK7KGFpl213l3JmZmTg7NTUV5SojYOvr63H28uXLcfbs2bNxdmlpKc5W7sPBgwfj7P3796Nc5XNVvtvKM/P06dM4m/LmB7Sk/ICWlB/QkvIDWlJ+QEvKD2hJ+QEtKT+gJeUHtDTa2dl52dfwH1evXo0vamwsH1JJf9E+DMPw3XffRblvv/02PvPNN9+Ms5XFTJWlNZWJlMrimspkQWWJ0traWpT7+eef4zPTpUjDMAw3btyIs5OTky8k++DBgzg7PT0dZ9P7W/m+KlNMlee28rk+/fTTaDzKmx/QkvIDWlJ+QEvKD2hJ+QEtKT+gJeUHtKT8gJaUH9CS8gNa2pULjCrLe7a2tuLsvXv34uzvv/8e5Sojc3Nzc3H28ePHLyRbGVmrZD/++OM4u7m5GWd/+OGHKFdZ4nT+/Pk4+++//8bZysha5blNR/yGobYU6NChQ1Hu2bNn8Znb29txtjLmuLy8HGdT3vyAlpQf0JLyA1pSfkBLyg9oSfkBLSk/oCXlB7Sk/ICWlB/Q0q4cb6uMFP39999x9vvvv4+zCwsLUa5yrZVxnsrnqmz3qoysVTa9Vcaanj59GmeXlpaiXGULYWVcbGJiIs5WRssq323l/lbG/MbHx59rruqvv/6Ks5URzpQ3P6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oSfkBLSk/oCXlB7S0K8fbVlZW4mw6hjYMtZGi9BpOnToVn1nZHvfrr7/G2croz/r6epytSDeBDUNtDOzkyZNR7uHDh/GZldHByvjiH3/88ULOrYyXTU9Px9n0PlRG/Cqb3lZXV+Psn3/+GWdT3vyAlpQf0JLyA1pSfkBLyg9oSfkBLSk/oCXlB7Sk/ICWlB/Q0q4cb6uMKlVGxh49ehRnnzx5EuUqoz/Ly8tx9vbt23H26NGjcXbfvn1xNh0tG4ZhmJ+fj7MVY2PZI7pnT/7/eOX5unXrVpytjE9WRtYq2dFo9NzPrWy7q1zrP//8E2crY3Mpb35AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oabSzs/Oyr+E/Pvzww/iiKtuqKhvGtra2olxlC1dlDK1i7969cbaybe7ixYtx9ssvv4yzN2/ejLNTU1NR7t13343PfOutt+LstWvX4uyxY8fi7BtvvBFnjxw5Emcrz2P6LMzNzcVnvv3223G28n1VPtfMzEw04+fND2hJ+QEtKT+gJeUHtKT8gJaUH9CS8gNaUn5AS8oPaEn5AS3tyu1t6ea0YahtgDpw4ECc3b9/f5SrbG+rZA8ePBhnK5utKtvbKucuLi7G2co4Xjq++Oqrr8ZnVkb8fvnllzi7sbERZyvPbWUEdXNzM86mfw+VLX6V7+Du3btx9kWM4XrzA1pSfkBLyg9oSfkBLSk/oCXlB7Sk/ICWlB/QkvIDWlJ+QEu7crzt+PHjcbYyBlbZRpaO/iwvL8dnHj58OM5Wxp8uXboUZ1/UtrvKZxuNouVawzAMw9mzZ6Pc5ORkfOaDBw/ibGUUb3V1Nc5WtsJV/h727MnfZ955550ot7a2Fp9ZGSEdHx+Psy+CNz+gJeUHtKT8gJaUH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0tCvH2+bn5+NsZcPYiRMn4my6BWt9fT0+s3KtldGyCxcuxNlz587F2bGx/PGojDVtb2/H2XR8sTKGVtn09tNPP8XZyhhYZcSvMkJZeR7TUbjK/VpYWIizlXMrWwfTZ9ybH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1raleNtlbGXubm5OFsZL1taWnquuWEYhqmpqThbGUOrbE47evRonK18tidPnsTZmZmZOJuOt1U+V+X7OnbsWJw9cuRInK1s59vY2Iizjx8/jrPpCGeaG4ba9rjKMzMxMRFnU978gJaUH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlkY7Ozsv+xr+4/PPP48vqvLr88pyl/RX9ZUzK7++r/yqv3IP79+/H2dff/31OPvRRx/F2cokxOnTp6NcZWLi7t27cfbatWtxNr3WqocPH8bZ8fHxOJt+Z5UpqnQip6qyxOmLL76ItkN58wNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLu3KBUWUMbG1tLc5WFvKki1gq43WVxT2Tk5Nx9unTp3F23759cXZ6ejrOrqysxNnKIqkDBw5Eub1798Znbm1txdnKMq3Kc1tZ9FMZb6uMOqbjeJXntvL3sLi4GGcXFhbibMqbH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1raleNtlU1cldGuQ4cOxdnZ2dkoV9my9t5778XZV155Jc5ev349zv72229x9tSpU3G2shGtMpKYqowD/vjjj3G2cn/HxvI/p8r9rZxb2Z525syZKFcZiayMt+3fvz/OVjb+pbz5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oSfkBLSk/oKVdOd42Pj4eZyvjPJURqFRla9iVK1fibLq1bBhq42LLy8txtrKN7M6dO3H21q1bz/3cyrVW/v3KiN/6+nqcffLkSZytPONTU1NxNh2bq4yQVsYBK99XZSwz5c0PaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oSfkBLe3K8badnZ04W9nIduHChTibjq3dv38/PvPy5ctx9saNG3G2Mgo3PT0dZ7e2tuLsyspKnK2MS6WjaJXnYHt7O85W7u9oNIqzlW1kR48ejbOVccuJiYkot7q6Gp9ZeQ4qWwcr44spb35AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oaVQZJQP4/8KbH9CS8gNaUn5AS8oPaEn5AS0pP6Al5Qe0pPyAlpQf0JLyA1pSfkBLyg9oSfkBLSk/oCXlB7Sk/ICWlB/QkvIDWlJ+QEvKD2hJ+QEtKT+gJeUHtPQ/xLD2BcGKKrUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf28671750>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 拿到卷积层的卷积核，并且显示一下图（卷积核为高维特征，人眼已经看不懂了。。。）\n",
    "plt.imshow(solver.net.params['conv1'][0].diff[:, 0].reshape(4, 5, 5, 5)\n",
    "       .transpose(0, 2, 1, 3).reshape(4*5, 5*5), cmap='gray')\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0 testing...\n",
      "Iteration 25 testing...\n",
      "Iteration 50 testing...\n",
      "Iteration 75 testing...\n",
      "Iteration 100 testing...\n",
      "Iteration 125 testing...\n",
      "Iteration 150 testing...\n",
      "Iteration 175 testing...\n",
      "CPU times: user 1min 6s, sys: 109 ms, total: 1min 6s\n",
      "Wall time: 1min 6s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# 指定迭代次数\n",
    "niter = 200\n",
    "# 指定测试周期\n",
    "test_interval = 25\n",
    "# losses will also be stored in the log\n",
    "# 初始化loss变量\n",
    "train_loss = np.zeros(niter)\n",
    "# 初始化测试准确率变量\n",
    "test_acc = np.zeros(int(np.ceil(niter / test_interval)))\n",
    "# 初始化输出变量\n",
    "output = np.zeros((niter, 8, 10))\n",
    "\n",
    "# the main solver loop\n",
    "# 开始迭代\n",
    "for it in range(niter):\n",
    "    # 每个循环迭代一次\n",
    "    solver.step(1)  # SGD by Caffe\n",
    "\n",
    "    # store the train loss\n",
    "    # 记录loss值（仅用于打印，loss的优化已经在caffe的内部做了）\n",
    "    train_loss[it] = solver.net.blobs['loss'].data\n",
    "\n",
    "    # store the output on the first test batch\n",
    "    # (start the forward pass at conv1 to avoid loading new data)\n",
    "    # 测试网络前进一步，用于获取数据（这里指定了start，用意何为呢？）\n",
    "    solver.test_nets[0].forward(start='conv1')\n",
    "    # 获取前8个数据\n",
    "    output[it] = solver.test_nets[0].blobs['score'].data[:8]\n",
    "\n",
    "    # run a full test every so often\n",
    "    # (Caffe can also do this for us and write to a log, but we show here\n",
    "    #  how to do it directly in Python, where more complicated things are easier.)\n",
    "    # 如果到达了开始测试的点，就开始测试\n",
    "    if it % test_interval == 0:\n",
    "        print 'Iteration', it, 'testing...'\n",
    "        correct = 0\n",
    "        for test_it in range(100):\n",
    "            # 测试网络前向传播，获取测试结果\n",
    "            solver.test_nets[0].forward()\n",
    "            # 把准确的记录下来，用于算准确率\n",
    "            correct += sum(solver.test_nets[0].blobs['score'].data.argmax(1) == solver.test_nets[0].blobs['label'].data)\n",
    "        # 计算准确率\n",
    "        test_acc[it // test_interval] = correct / 1e4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,u'Test Accuracy: 0.94')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf1bf19dd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 制作一条曲线\n",
    "_, ax1 = plt.subplots()\n",
    "# 增加一条曲线\n",
    "ax2 = ax1.twinx()\n",
    "# 绘制训练的loss曲线\n",
    "ax1.plot(np.arange(niter), train_loss)\n",
    "# 绘制测试的准确率曲线\n",
    "ax2.plot(test_interval * np.arange(len(test_acc)), test_acc, 'r')\n",
    "# 设置坐标轴信息\n",
    "ax1.set_xlabel('iteration')\n",
    "ax1.set_ylabel('train loss')\n",
    "ax2.set_ylabel('test accuracy')\n",
    "ax2.set_title('Test Accuracy: {:.2f}'.format(test_acc[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2082d8d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf1be44990>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf204e2fd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf1bf88b10>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf1bf84750>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf200878d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2013ec10>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20204ed0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2051d450>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20710e50>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20e219d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20450890>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJIAAACPCAYAAAARM4LLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAB+1JREFUeJzt3V2IFOkVBuD3jcmCoMhM/HclO4KErCgGl2CIfxDUcb3YCxFWNCoOqJhIIkHcNeKF3uyNuYvCgDKiYeNPorsousYlQYIh+INGJ+I6iquDg+OKEu909ctF9wx9Kk53WX26qrrnfWDoPtXVXUc5fPVVddVphhAgUq3vZJ2ANAYVkrhQIYkLFZK4UCGJCxWSuFAhiQsVkrioqpBItpK8SbKL5EdeSUn9YdIz2ySHAPgKwHwA3QAuAFgWQvhPmffoNHr9+SaEMKrSStWMSD8B0BVCuBNCeA7gTwA+qOLzJJ++jrNSNYU0AcD9kri7uMwguZbkRZIXq9iW5Nx3q3gvX7Ps/3ZdIYR2AO2Adm2NrJoRqRvAxJL4bQAPqktH6lU1hXQBwGSSLSTfAvAhgM990pJ6k3jXFkL4luSvAHwBYAiAfSGETrfMpK4kPvxPtDHNkerRpRDCe5VW0pltcaFCEhcqJHGhQhIXKiRxoUISFyokcaFCEhcqJHGhQhIXKiRxUc31SHVt9OjRJj58+LCJz58/b+L29nYT3717tyZ5xTFixAgTz5kzx8SnT5/uf/7ixYtUctKIJC5USOJChSQuBs0cqampycSdnfYavOi84+HDhybO05zo0qVLJh41yt4tNGPGjP7nXV1dtUushEYkcaFCEhcqJHHRsHOkkSNHmvjQoUMmbm5uNvHu3btNvHHjxtoklsC2bdtM3NLSYuJ169aZOK15USmNSOJChSQuVEjiomHva1uwYIGJT506VXb9sWPHmvjRo0fuOcU1ZcoUE1+7ds3Ex44dM/Hq1atN/OzZM890dF+bpEeFJC5USOKiYc4jRa8vWrJkSdn129raTJynOdHZs2fLrh+dIznPiRLRiCQuKhYSyX0ke0leL1nWTPKvJG8VH5vKfYY0vjgjUgeA1siyjwB8GUKYDODLYiyDWMU5UgjhHMl3Ios/ADCv+Hw/gL8D2OKY1xvbtWuXiVesWGHi6DU8R44cqXlOcc2ePdvEY8aMMXFHR4eJDx48WOuU3ljSOdKYEEIPABQfR1dYXxpczY/aSK4FsLbW25FsJR2RHpIcBwDFx96BVgwhtIcQ3otzml3qV9IR6XMAqwB8Unz8zC2jhKLfGb569crEDx7Yzs3Pnz+veU59hg4dauKtW7eaeMOGDSaO/lvWrFlTm8QcxTn8/xTAPwH8kGQ3yTYUCmg+yVso/BbJJ7VNU/IuzlHbsgFe+rlzLlLHdGZbXDTMd22VLF682MRnzpwx8dOnT028Z8+exNuaO3euiefNm2fimTNnln3/0aNHE287KxqRxIUKSVyokMRFw1yzXXq/OwAcP37cxOPHjy/7ftL+/Fw1/y9v+ll37twxcWur/Y789u3biXNxoGu2JT0qJHHRMIf/0ctEpk2bZuLp06ebOLr72Lx5s4mjl97u378/di4HDhww8dWrV8uuH20zmPGuLBGNSOJChSQuVEjiomEO//Nk0qRJJo62mbly5YqJFy5caOIsb416DR3+S3pUSOJChSQuGuY8Up5s377dxNF56JYt9s6tnM2JEtGIJC5USOJChSQuNEdysHTpUhOvXLnSxNG2M48fP655TmnTiCQuVEjiQoUkLjRHcrBo0aKyr584ccLEly9frmU6mdCIJC5USOJChSQudD2Sg56eHhMPGzbMxNFbuOtsjqTrkSQ9cfojTST5N5I3SHaS/HVxuVokS784I9K3AH4bQvgRgJkAfknyXahFspSI02irB0BfB9tnJG8AmIActkhO0/r16/ufR9sZ9/balpp1NidK5I3mSMV+2z8G8C+oRbKUiH1mm+QwAH8G8JsQwn+jjRLKvE/tkQeBWCMSye+hUER/DCH8pbg4VotktUceHCqOSCwMPXsB3Agh/L7kpdy1SE5T6Rwpei7u5MmTZd87fPhwEzc12QPee/fuVZld+uLs2n4G4BcArpHsu7NvKwoFdLjYLvkegKUDvF8GgThHbf8AMNCESC2SBYDObIsTXY9UAy9fvjTx8uXLTbxp0yYTd3Z2mnjVqlW1SayGNCKJCxWSuFAhiQtdj5RQaY+jqVOnmtcqtUfeu3eviXfu3Gni+/fve6ToRdcjSXpUSOJCu7aEZs2a1f98x44d5rVz586ZOPpLS0+ePDFxmr9mmYB2bZIeFZK4UCGJC82RpBLNkSQ9KiRxoUISFyokcaFCEhcqJHGhQhIXKiRxoUISFyokcaFCEhdp3470DYCvAYwsPs+jvOaWVV4/iLNSql/a9m+UvJjXphJ5zS2vefXRrk1cqJDERVaF1J7RduPIa255zQtARnMkaTzatYmLVAuJZCvJmyS7SGbaTpnkPpK9JK+XLMtF7/B67G2eWiGRHALgDwAWAXgXwLJiv+6sdABojSzLS+/w+uttHkJI5Q/ATwF8URJ/DODjtLY/QE7vALheEt8EMK74fByAm1nmV5LXZwDm5zW/EEKqu7YJAEq7I3QXl+VJ7nqH10tv8zQL6XV9KHXIWEa0t3nW+ZSTZiF1A5hYEr8N4EGK248jVu/wNFTT2zwLaRbSBQCTSbaQfAvAhyj06s6Tvt7hQIa9w2P0Ngfy1ts85Unj+wC+AnAbwO8ynsB+isKP9bxAYbRsA/B9FI6GbhUfmzPKbRYKu/1/A7hS/Hs/L/m97k9ntsWFzmyLCxWSuFAhiQsVkrhQIYkLFZK4UCGJCxWSuPgfIwVPKDT0HEsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20e3dc10>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAACdCAYAAABGmSdgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAEhdJREFUeJzt3X+MZXV5x/HPZ38xs7uzrAIaZalgQ6mUFGhGuhZqCZAGlYIxGKFQqZpsf6lANQT8h2DTxMbGYhpTsgGEthRKgAppVCR2EaUtMCzLzy1KQXdXEBbkx+7M/t6nf9xDGYdlzvdZ5jv33PX9Sghz7n3uOd97v+ee++w95z6PI0IAAAB4Y3P6PQAAAICuI2ECAABoQcIEAADQgoQJAACgBQkTAABACxImAACAFiRMAAAALUiYAAAAWpAwAQAAtJjX7wFMtnDhwliyZMmMr7dGNfNaFdKpvF5P5rXtQuzu3bv7PoZ+G7TXqzS239vPst332Iwa6x20Y36/95tBOs7s3r1bEdG603QqYVqyZInOO++8otjMwXHXrl3FsaXrzayzxval/r8haqrxwZN5bXfu3Fkcu2PHjuLYrVu3FsdOTExUGUMmtt8yY922bVuV9WZit2/fPqNxUm5fzMRmkop588o/KubPn18cO3fu3OLYzHhL15tZZ+a17ffnUzY289xKx9uFz7LS2C1bthTFVT0lZ/tU24/bfsL2xTW3BQAAUEu1hMn2XElfk/QBSUdKOtv2kbW2BwAAUEvNb5iOk/RERDwZEdsl3SDpjIrbAwAAqKJmwnSwpPWTljc0twEAAAyUmgnTnq6me90VWLZX2B6zPVZ64RUAAMBsqpkwbZB0yKTlZZKenhoUESsjYjQiRoeHhysOBwAAYO/UTJjuk3S47cNsL5B0lqTbKm4PAACgimp1mCJip+1PS7pd0lxJV0fEo7W2BwAAUEvVwpUR8U1J36y5DQAAgNo6Vek7Ioor4Nao+pqJzVSzrSVTITZTHTWz3loVk0srz9aqvlurSm1mv1m0aFFxbI3K5LUqZ2fG2oUK9Zl9odScOeVXQ2SqbNc41km58Q4NDRXHjoyMFMfut99+xbGZ8ZbqQqXvWsf8GpW+a6lxHF+/fn17kGi+CwAA0IqECQAAoAUJEwAAQAsSJgAAgBYkTAAAAC1ImAAAAFqQMAEAALQgYQIAAGhBwgQAANCChAkAAKBFp1qj2C4u158pfZ9po1Iam1lnRq1WEJly9pnXNtNeIfPcSl/fzFi70BolE5t5bTMtVxYsWFAUl2lFUWu/zbzPMvt4pu1LjbYzpS2gpHotamq15Mg8t3Xr1lVZb415yOwHGZljWOZ9nonNtN8pHW+Nz12pTsuX0ji+YQIAAGhRLWGyfYjtVbbX2n7U9vm1tgUAAFBTzVNyOyV9LiJW2x6RdL/tOyLisYrbBAAAmHHVvmGKiGciYnXz9yZJayUdXGt7AAAAtczKNUy2D5V0rKR79nDfCttjtscmJiZmYzgAAAAp1RMm24sl3Szpgoh4Zer9EbEyIkYjYnThwoW1hwMAAJBWNWGyPV+9ZOm6iLil5rYAAABqqfkrOUu6StLaiPhKre0AAADUVvMbpuMl/ZGkk2yvaf77YMXtAQAAVFGtrEBE/EBSnXLYAAAAs6hzrVFK2zb0W61WEBmZ1hmZ8vsZmfnqd4uaTGzmeWXaCmRia7UFKW37UmOdWZn3Wa02F5nnVqN9RqZFzaJFi4pj999//+LY4eHh4tjMeLdu3Voc+8orr/vN0Bsq/cX1+Ph48Toz+8HQ0FBxbObHTrXmIdNGpfSzJHP8yLT0yfyavvSYcMUVVxTF0RoFAACgBQkTAABACxImAACAFiRMAAAALUiYAAAAWpAwAQAAtCBhAgAAaEHCBAAA0IKECQAAoAUJEwAAQItOtUbZvXt3qlR+qUxbkNLYTFuSWu07ajwvqV7LlRotRDLrzJT/z6w304Ig0wYhMw8ZNdp3ZF7bzGswMjJSZb2ZFiKZfaF0zjLrzLTpqTG32THUOibUaPWRGWutFjmZlj6Z8fb7s6TW9mt8nt56661FcdPurbY/Mt39EXFL0VYAAAAGWFt6/wfT3BeSWhMm23MljUn6aUSclhgbAABAJ0ybMEXEJ2ZgG+dLWitpyQysCwAAYNYVnTi0/XbbV9n+VrN8pO1PFTxumaQPSbryzQ0TAACgf0qvtLpG0u2S3tks/1DSBQWPu1zSRZLe8Go52ytsj9ke27JlS+FwAAAAZk9pwnRgRNyoJvGJiJ2Sdk33ANunSXouIu6fLi4iVkbEaESMDg8PFw4HAABg9pQmTOO2D1DvQm/ZXi7p5ZbHHC/pdNs/lnSDpJNs//PeDhQAAKBfSotg/KWk2yT9qu27JR0k6czpHhARl0i6RJJsnyjp8xFx7t4PFQAAoD+KEqaIWG379yQdIcmSHo+IHVVHBgAA0BFFCZPtIUl/LukE9U7Lfd/2FRFRVJY7Iu6UdGdBXJVK3xk1qpj2u+KqVK8yeS0RURS3a9e0l9Lt1TqlXFXfzBgyr22msnGmEvPQ0NCMbz8j8+OOiYmJ4thNmzYVx+7YUeffe6XVxg888MDidS5ZUl6RJXMdaGa/zVSj3rZtW3FsZh4y1bNrVDzP7IuZz7HMWDPHpVpV1EtjS48z2dhMRf/S9W7cuLEorvQV/UdJmyT9fbN8tqR/kvTRwscDAAAMrNKE6YiIOHrS8irbD9YYEAAAQNeUntN5oPllnCTJ9m9LurvOkAAAALqlrfnuw+pdszRf0sdtr2uW3yXpsfrDAwAA6L+2U3I0ywUAAL/02prv/mTysu23SSq/nB0AAGAfUNp893TbP5L0lKTvSfqxpG9VHBcAAEBnlF70/VeSlkv6YUQcJulkcdE3AAD4JVGaMO2IiBckzbE9JyJWSTqm4rgAAAA6o7QO00u2F0u6S9J1tp+TNPOlVAEAADqoNGE6Q9JWSRdKOkfS/pK+ONODmTNnjkZGRmZ6tSmlpedrtdnoQvuOzHozarQxyYw104YhM9bMemvNWY1WEJl2OrVa+mRk2s5kWleMj48Xx5a2fdm8eXPxOjMtOTItTDL7ba2WPvPnzy+OrdFqI7POzFgzx/HMvlir5UomtvS5ZfaZTBuXzHGpdM5eeOGForjS5ruTjxjXFq0ZAABgH9FWuHKTeoUqX3eXpIiIabtC2l4q6UpJRzXr+WRE/NdejhUAAKAv2uowvdnzY1+V9O2IONP2AknlbYYBAAA6ovzEYZLtJZLeL+mPJSkitksqP8EOAADQEXWuvux5t6SNkr5u+wHbV9peVHF7AAAAVdRMmOZJ+i1J/xARx0oal3Tx1CDbK2yP2R4r/YUJAADAbKqZMG2QtCEi7mmWb1IvgfoFEbEyIkYjYnR4eLjicAAAAPZOtYQpIn4mab3tI5qbTpb0WK3tAQAA1FLtou/GZ9SrDL5A0pOSPlF5ewAAADOuasIUEWskjdbcBgAAQG21v2FKKy27nik9X6vdSA2ZcvKZ2Ew7ilrrzcSWlrTPtDZYsGBBcWym/H5GrTYINdqzZN43mbYRixcvLo5dtKj8h7WZ2MwYMm0bSl+zWu1hMsevTDuMbdu2VYnN7GMZpcewzDxkjh+Z90Nm/8qMt9/tnWp9RmeUjvWyyy4riqt50TcAAMA+gYQJAACgBQkTAABACxImAACAFiRMAAAALUiYAAAAWpAwAQAAtCBhAgAAaEHCBAAA0IKECQAAoEWnWqNEhLZv397vYRSp1cIko1b7jkz5/cwYMrGlpfK3bNlSvM5MbK1S/ZmWCZm2L5m2IKXzm2mzUasNw/PPP18cu3nz5uLYF198sTg20xKjdM4yx4TMPGTeY7VacmRiM21UMq1cxsfHi+Iy+2Lm9crMQ+Z9vnDhwuLY4eHh4th+Hz9qtd4pbS9VOla+YQIAAGhRNWGyfaHtR20/Yvt62+WpNAAAQEdUS5hsHyzps5JGI+IoSXMlnVVrewAAALXUPiU3T9Kw7XmSFkp6uvL2AAAAZly1hCkifirpbyWtk/SMpJcj4jtT42yvsD1meyxzUS4AAMBsqXlK7i2SzpB0mKR3Slpk+9ypcRGxMiJGI2I0c1U/AADAbKl5Su4USU9FxMaI2CHpFkm/U3F7AAAAVdRMmNZJWm57oXtFR06WtLbi9gAAAKqoeQ3TPZJukrRa0sPNtlbW2h4AAEAtVSt9R8Slki6tuQ0AAIDaOtUaRcqV1e+nTOn7TBuEWi0IMjItAGq1Vyh9fWu1qMk8r0y7k8xrUKs1yuLFi4viMs8rI9PiItNeIfPa1ni9pPI2Kpl9MdN2JvPaZn6VnGlHkWkrVKtV0MjIyIzGSblWI5njR8bExERxbKb9T6atUGm7kcx+u3Tp0uLYzD5T+j4vjRuM7AQAAKCPSJgAAABakDABAAC0IGECAABoQcIEAADQgoQJAACgBQkTAABACxImAACAFiRMAAAALUiYAAAAWjhTxr422xsl/WTKzQdKer4Pw8HeY84GC/M1eJizwcOcdde7IuKgtqBOJUx7YnssIkb7PQ6UY84GC/M1eJizwcOcDT5OyQEAALQgYQIAAGgxCAnTyn4PAGnM2WBhvgYPczZ4mLMB1/lrmAAAAPptEL5hAgAA6KtOJ0y2T7X9uO0nbF/c7/Hg9Wxfbfs5249Muu2ttu+w/aPm/2/p5xjxGtuH2F5le63tR22f39zOnHWU7SHb99p+sJmzy5rbD7N9TzNn/2p7Qb/HitfYnmv7Adv/3iwzXwOuswmT7bmSvibpA5KOlHS27SP7OyrswTWSTp1y28WSvhsRh0v6brOMbtgp6XMR8R5JyyX9RfO+Ys66a5ukkyLiaEnHSDrV9nJJfyPp75o5e1HSp/o4Rrze+ZLWTlpmvgZcZxMmScdJeiIinoyI7ZJukHRGn8eEKSLiLkk/n3LzGZKubf6+VtKHZ3VQeEMR8UxErG7+3qTeAf1gMWedFT2bm8X5zX8h6SRJNzW3M2cdYnuZpA9JurJZtpivgdflhOlgSesnLW9obkP3vT0inpF6H9CS3tbn8WAPbB8q6VhJ94g567Tm9M4aSc9JukPS/0p6KSJ2NiEcH7vlckkXSdrdLB8g5mvgdTlh8h5u4yd9wAywvVjSzZIuiIhX+j0eTC8idkXEMZKWqfft+3v2FDa7o8Ke2D5N0nMRcf/km/cQynwNmHn9HsA0Nkg6ZNLyMklP92ksyHnW9jsi4hnb71DvX8XoCNvz1UuWrouIW5qbmbMBEBEv2b5TvevPltqe13xrwfGxO46XdLrtD0oakrREvW+cmK8B1+VvmO6TdHjzy4IFks6SdFufx4Qyt0k6r/n7PEm39nEsmKS5luIqSWsj4iuT7mLOOsr2QbaXNn8PSzpFvWvPVkk6swljzjoiIi6JiGURcah6n1v/ERHniPkaeJ0uXNlk6JdLmivp6oj46z4PCVPYvl7Siep14n5W0qWSviHpRkm/ImmdpI9GxNQLw9EHtk+Q9H1JD+u16yu+oN51TMxZB9n+TfUuEp6r3j9yb4yIL9p+t3o/hnmrpAcknRsR2/o3Ukxl+0RJn4+I05ivwdfphAkAAKALunxKDgAAoBNImAAAAFqQMAEAALQgYQIAAGhBwgQAANCChAnArLP9n83/D7X9hzO87i/saVsA8GZQVgBA30yuU5N4zNyI2DXN/ZsjYvFMjA8AXsU3TABmne3NzZ9fkvS7ttfYvrBpMvtl2/fZfsj2nzTxJ9peZftf1Cu6KdvfsH2/7Udtr2hu+5Kk4WZ9103elnu+bPsR2w/b/tikdd9p+ybb/2P7uqYiOgD8vy73kgOw77tYk75hahKflyPivbb3k3S37e80scdJOioinmqWPxkRP2/ahdxn++aIuNj2p5tGtVN9RNIxko5WrzL9fbbvau47VtJvqNff6271+oH9YOafLoBBxTdMALrk9yV93PYa9dq1HCDp8Oa+eyclS5L0WdsPSvpv9Rp1H67pnSDp+ojYFRHPSvqepPdOWveGiNgtaY2kQ2fk2QDYZ/ANE4AusaTPRMTtv3Bj71qn8SnLp0h6X0RM2L5Tvc7wbet+I5N7eu0Sx0YAU/ANE4B+2iRpZNLy7ZL+zPZ8SbL9a7YX7eFx+0t6sUmWfl3S8kn37Xj18VPcJeljzXVSB0l6v6R7Z+RZANjn8a8oAP30kKSdzam1ayR9Vb3TYaubC683SvrwHh73bUl/avshSY+rd1ruVSslPWR7dUScM+n2f5P0PkkPSgpJF0XEz5qECwCmRVkBAACAFpySAwAAaEHCBAAA0IKECQAAoAUJEwAAQAsSJgAAgBYkTAAAAC1ImAAAAFqQMAEAALT4P0YLSzPH2bApAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf1bdc5090>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20537790>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf202c4bd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 测试数据展示，这个matplot咱还不太会用，之后一定要出一个matplot的博客：）\n",
    "for i in range(8):\n",
    "    plt.figure(figsize=(2, 2))\n",
    "    plt.imshow(solver.test_nets[0].blobs['data'].data[i, 0], cmap='gray')\n",
    "    plt.figure(figsize=(10, 2))\n",
    "    plt.imshow(output[:50, i].T, interpolation='nearest', cmap='gray')\n",
    "    plt.xlabel('iteration')\n",
    "    plt.ylabel('label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20924250>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf202fa310>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2081b790>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf203fcc50>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf203fe0d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf208c6610>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf208cb950>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20159c90>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf2075efd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf206c7bd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJIAAACPCAYAAAARM4LLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAABqhJREFUeJzt3c1rVGcUBvDn0UZBuqnpB2Kkikip6KIQS2uDFIqYCuJCCyqULgQ3DbTQRbX5B1wVXBQ1ULFISSm0aHYapKUUSkkCoY2VaFpIHJRKFtoiCfnwdDE3Ye5tZuZm5tyv5PlBmHnv3HHO4vG9n3OGZgaRZq3JugBZGRQkcaEgiQsFSVwoSOJCQRIXCpK4UJDERVNBItlJcpTkGMnTXkVJ8bDRM9sk1wK4A2A/gBKAAQDHzeyPGu/RafTimTSzF+qt1MyM9DqAMTP7y8xmAHwD4HAT/57k03iclZoJ0mYA9yrGpWBZCMlTJAdJDjbxWZJzzzTxXi6x7H+bLjPrAdADaNO2kjUzI5UAbKkYtwG431w5UlTNBGkAwA6S20iuA3AMQJ9PWVI0DW/azGyOZBeA6wDWArhkZrfcKpNCafjwv6EP0z5SEQ2ZWXu9lXRmW1woSOJCQRIXCpK4UJDEhYIkLhQkcaEgiQsFSVwoSOJCQRIXzdyPJDEdOnQoNO7rC98k0dXVFRpfuHAhNJ6fn0+mMEeakcSFgiQuFCRxofuREtDa2hoaDw8Ph8ZtbW01379hw4bQeGpqyqewxuh+JEmPgiQuFCRxofNICdi3b19oXG+fqLe3NzSenp52rylpmpHEhYIkLhQkcaF9JAfr168Pjbu7u5f1/itXroTGRWyirxlJXChI4kJBEhe61uagvT18KWpgYKDm+nNzc6FxS0uLe02OdK1N0lM3SCQvkXxIcqRi2UaS/STvBo/PJVum5F2cGekygM7IstMAbprZDgA3g7GsYnXPI5nZTyS3RhYfBvB28PwrAD8C+NSxrkI5cuTIsta/ceNGQpVkp9F9pJfM7AEABI8v+pUkRZT4mW2SpwCcSvpzJFuNzkh/k9wEAMHjw2ormlmPmbXHOYSU4mp0RuoD8AGAs8HjNbeKCih6/1HUzMxMaLzca3FFEOfwvxfALwBeIVkieRLlAO0neRfl3yI5m2yZkndxjtqOV3npHedapMB0Zltc6H6kBu3du3fJ50t58uRJaBz9nttKoBlJXChI4kJBEhfaR2rQnj17Yq97/vz5BCvJB81I4kJBEhfatDUoenttpUePHoXG2rSJxKQgiQsFSVxoHymmjo6O0PjEiRNV1338+HFoXCqVEqkpTzQjiQsFSVwoSOJC+0gxRVser1lT/f9gf39/0uXkjmYkcaEgiQsFSVxoHymmo0ePVn0tem3t4sWLSZeTO5qRxIWCJC4UJHGh1n9VRH/2YXx8PDSuPI80MjISem337t3JFZY+tf6T9ChI4kJBEhc6j1RF9GvYta6tXb16Nelyck8zkriI0x9pC8kfSN4meYvkR8FytUiWRXFmpDkAn5jZqwDeAPAhyZ1Qi2SpEKfR1gMACx1s/yV5G8BmrPAWydH7j6ImJycXn587dy7pcnJvWftIQb/t1wD8CrVIlgqxj9pIPgvgOwAfm9k/JOO+T+2RV4FYMxLJFpRD9LWZfR8sjtUiWe2RV4e6MxLLU8+XAG6b2ecVL63oFskHDhyo+frExMTi8+j32FajOJu2twC8D+B3kgvNDz9DOUDfBu2SJwC8l0yJUgRxjtp+BlBth0gtkgWAzmyLE11rC0R/DnT79u0115+enl58Pjs7m0hNRaIZSVwoSOJCQRIX2kcKPH36NDQeHBwMjXft2hUaj42NJV5TkWhGEhcKkrjQpi0wPz8fGkd/5TH6ta2hoaHEayoSzUjiQkESFwqSuNBXtqUefWVb0qMgiQsFSVwoSOJCQRIXCpK4UJDEhYIkLhQkcaEgiQsFSVykfT/SJIBxAM8Hz/Mor7VlVdfLcVZK9aLt4oeSg3ltKpHX2vJa1wJt2sSFgiQusgpST0afG0dea8trXQAy2keSlUebNnGRapBIdpIcJTlGMtN2yiQvkXxIcqRiWS56hxext3lqQSK5FsAXAN4FsBPA8aBfd1YuA+iMLMtL7/Di9TY3s1T+ALwJ4HrF+AyAM2l9fpWatgIYqRiPAtgUPN8EYDTL+irqugZgf17rM7NUN22bAdyrGJeCZXmSu97hReltnmaQlupDqUPGGqK9zbOup5Y0g1QCsKVi3AbgfoqfH0es3uFpaKa3eRbSDNIAgB0kt5FcB+AYyr2682ShdziQYe/wGL3Ngbz1Nk95p/EggDsA/gTQnfEObC/KP9Yzi/JseRJAK8pHQ3eDx40Z1daB8mb/NwDDwd/BvNS31J/ObIsLndkWFwqSuFCQxIWCJC4UJHGhIIkLBUlcKEji4j9+YMQOhEzaJQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf207def10>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20628190>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf209737d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf206505d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf20884b10>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf28347110>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 这个展示采用了interpolation的nearest，方便人来观看（是不是觉得第二张图清楚了）\n",
    "for i in range(8):\n",
    "    plt.figure(figsize=(2, 2))\n",
    "    plt.imshow(solver.test_nets[0].blobs['data'].data[i, 0], cmap='gray')\n",
    "    plt.figure(figsize=(10, 2))\n",
    "    plt.imshow(np.exp(output[:50, i].T) / np.exp(output[:50, i].T).sum(0), interpolation='nearest', cmap='gray')\n",
    "    plt.xlabel('iteration')\n",
    "    plt.ylabel('label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0 testing...\n",
      "Iteration 25 testing...\n",
      "Iteration 50 testing...\n",
      "Iteration 75 testing...\n",
      "Iteration 100 testing...\n",
      "Iteration 125 testing...\n",
      "Iteration 150 testing...\n",
      "Iteration 175 testing...\n",
      "Iteration 200 testing...\n",
      "Iteration 225 testing...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,u'Custom Test Accuracy: 0.88')"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAacAAAEWCAYAAADCeVhIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXl4ZGWV/z8n+550kk53el9omm6gAW0QEAUUlE3QcRnQUZnRQcZtHNTRmVFkcGZccFd+bojgisjogAqiIgJNgzQ0Se9Np/f0ls6+VmrJ+f3x3lu5qU4llaWydM7nee6TqrueqiT3e895z3uOqCqGYRiGMZXImGwDDMMwDCMREyfDMAxjymHiZBiGYUw5TJwMwzCMKYeJk2EYhjHlMHEyDMMwphwmToZhGMaUw8TJQETeLiLPi0iniBwRkUdE5KIxnvM2EfnJeNk4zLU6A0ufiPQE3r9jDOd9VkT+LoX9yrxr/mq015qOiMiVIvKSiHSJyJ9EZMEQ+64VkfUi0iYiB0Xkkwnb/05EdopIh4hsFpGr0/8JjKmMidMMR0RuAb4G/A8wB1gE/D/gusm0aySoapG/AAeANwTW/XQCTPhboBu4WkQqJuB6cUQkayKvF7huNfAL4ONAJbANGOph5H7gEaAcuAz4qIi8zjvXUuAHwPuBEuAzwP0iUpa2D2BMfVTVlhm6AKVAJ/DWIfa5B/ivwPtLgPrA+08Ah4AOYCfwWuAKIAxEvPPXevvOAx4CmoE64B8D57kN+CXuBtcBbAZOBf4NaAAOAq9L4TPtAy5LWJcJfBrYAzQCPwXKvG2FwH2eTa3AX4FZwJeBGBDyPsOXh7jmeu/824APJmxbAjzoXbcxeB7czXhH4POeCeQBCiwI7Hcf8Cnv9RXed/dp4BjwfWA27sZ/3PscDwLVgeMrgR8BR4EW4Bfe+jrg8sB+eUAbsCqF7/nDwJ8D78u83/mSQfbN9P4WlgXW/Qb4F+/1xcCBhGM6gHMm+3/ElslbzHOa2VyAuyH9ejQHi8hK4IPAuapaDLwe2Keqv8d5Yr9Q572c5R3yc6AeJ1JvAf5HRF4bOOUbgB/jxOFF4FGcdz8fuB347mjsxD3dvw64CFiAu1F+1dv2XiDLu0al93nCqvpRYAPwXu8zfDTJd7ACOB/4GU703hXYlo0Tje04j3Qh8L/etnfihP0GnLfwFpxwpMISINs734dx39F3vGss9fb5amD/XwACnIbzju/01v8ICIYtrwNeUtXtno07ReRvkthwOlDrv1HVVpzXenrijqoaA74JvFtEskXkdODlwGPeLuuBgyLyehHJFJG3AU24782YoZg4zWwqgEZVjY7y+BiQC6wWkWxV3aequwfbUUQW4sThE6oaUtUa4C7gnYHdnlLVRz17fonzCD6vqhGc97BklKGe9wGfVNXDqhoC/hP4WxERnFDNBparalRVN6hq1wjO/W7gOe9z/wxYKyKrvG0X4YTn31W1W1V7VHW9t+29wP+o6ovq2Kmq9Slesxf4rKqGvXMeU9UHvddtwOdw3ogfMnsV8H5VbfWOedI7z4+AN4pIgff+nbiHAwBUdaWqJhtHK8J5WUHagOIk+/8fTrh7gC3At1R1k3ediHfdX3uf7Qc4rzqU0rdhnJSYOM1smoDK0Y5bqGod8BFcSK5BRO4TkXlJdp8HNKtqR2DdfpzH4nMs8LoHJ5yxwHtwN8WU8QRoIfCwiLSKSCvOK8vAifMPgCeAB0SkXkT+R0QyR3Dud+I8JlR1L/AsTrDwrrtXVfsGOXwhMKiQp8BR74bu21EsIneLyAERaQf+gPMC/es0JHzvePbuw30X14nIbOA1uIeAVOjECW+QElw4bgAiMgd4GBeizcV5fm8WkX/wtr8B98BwIZCD88B/LCKrU7TFOAkxcZrZPIMbU3njEPt0AQWB93ODG1X1Z6p6EbAYN1byBX9TwnkOA+UiEnyyXoQbr0obqqreNV6jqmWBJU9VG1W1V1VvVdXTgFcDbwWuT/IZErkU9xluE5GjInIUOAv4OxHJwI2TLfFeJ3IQWD7Ien+sLul3Pohdn8SFK89V1RJcCFMC16kSkWSifi8utHc9bgypIcl+iWzFfVYARKQU9zewdZB9VwAdqnqfqsZUdT/OM77K236Wd+0aVe3zvMsanFgaMxQTpxmMFwK6FbhTRN4oIgXemMCVIvJFb7ca4CoRKReRuThPCXBjTiLyGhHJxYlcDy7UB84Lit+YVfUgbmzhcyKSJyJrgPfgeR1p5jvA573QIiJS5T2tIyKXichqz852IJrwGZYNcd53A7/FjbOc7S1n4TLSXgusw3kSn/W+23wRudA79i7gkyJyljhOFZEFnpe1GXiHN/7yBtzY4FAU47IFW0WkEviUv8Hz5p4EviUipSKSIyKvDhz7AC78+E+4MF+qPACcKyJvEJE8nOez3vPGEtkOFIrIW7zPOh83xuaPWW0ALhWRMwBE5DzcON6mEdhjnGxMdkaGLZO/AO8Ansd5SUeB3wEXetvycAPq7bibxb/gZesBa4DncDfgZtyNep63rQJ3c24BNnrrFnj7NONCWjcHbLgN+Eng/WW45Ar/fRYJWWxJPss+Bs/W+wSwy7O1DviMt+3d3nr/s38ZyPC2Xezt2wJ8MeGcRbjQ1uWD2HC3/1lwCQr+Zz4OfCmw34cCNm0CzvDWX4DL4mv3zvW/JGTrJVxvkfddd3rHvR+IBrbPxj0ENHh2/Dzh+J/gxovyEtbvBt48xHd9pWd/N/AnBmYY3gN8LfD+9cAL3nWOAt8OXg+4BZdN2eFd90OT/X9hy+QuomrNBg1jJiMi/wNUqep7J9sWw/CZlAl8hmFMDbxEiBsZetzRMCYcG3MyjBmKiHwQFwb9pao+N8nmGMYALKxnGIZhTDnMczIMwzCmHNNuzCkjI0Pz8/Mn2wzDMIxpRXd3t6rqtHFIpp045efn09U1kuoyhmEYhoj0DL/X1GHaqKhhGIaRXkTkCq/gb11izy1v+2IReUxENonIX4bq4TVWTJwMwzAMvJqSd+ImV68GbhikvuGXgB+p6hpcp4DPpcseEyfDMAwD4Dxc9ZE9qhrGFQFObDq6mv5WJ48Psn3cMHEyDMMwwHUIOBh4X8/ArgHg6iG+2Xv9JqA4Xd2fTZwMwzBmBlki8nxguSlhuwxyTOJE2I8BF4vIi7jak4dwxZLHnWmXrWcYhmGMiqiqrh1iez2u/5fPAlyrmziqehj4GwCvDcub1XU3GHfMczIMwzDAtS5ZISJLRSQH1+ProeAOIlIZ6E/2b7iq+WlhRnpOf9nZwIJZBZxSNaKmqoZhzDRiMWhuhoaG/uXYMffzwx+GqqrJtnDcUNWoV2/xUVybmbtVdauI3A48r6oPAZfgerIprk/YB9Jlz7SrrVdYWKhjmYTb1hPh3P/+E68/fS7fvOGccbTMMIxpQVdXv8AkW/ztjY3Q13fiOTIz4Zln4NxzJ97+USIi3apaONl2pMqM85we3nyEcLSPA01WZcKYQahCby90drqbs/8z2etU13V1ufPm5UFBgVvy88f2c6htOTkgCeP20agTkWQCk7h0dw/+HZWUOE+oqgpOOQUuvBDmzOlfF1zKyyHDRkXSyYwTp19trAdgf3OSP1DDGC3Hj8OhQ+5mGYu5n4MtQ20by7E9PUMLyWAeQDIyM6GoyC2FhW4pKoKKCli8eOC6nBwIhdz1u7vd4r/u6XFhscG2jSZqI9IvVvn57jzNzYOfKytroKCcempysamqcgJrTBlmjDjF+pRv/nkXG/a1MLckj6PtIdp6IpTmZ0+2acZ0QhUOHoTt2/uXbdvcz6am9F03M9PdbAdb/G35+f1iUl7e/zpRYFJZN5iHMp6oQjg8UKwSRW2wn4nrCgoGF5o5c6CsLL2fwUgrM0ac7n/+IF/70y7edM58Lj51Nh/5RQ0Hmro5c0HpZJtmTEUiEdi9e6AIbd8OO3Y4L8SnvBxWrYI3vcn9XLzY3diTCchwAjPYkpFx8t1kRSA31y2zZk22NcYUZMaI01tfvoDywhxet3oO2490ALC/ucvEaabT3Q07d57oBdXVOYHyWbDAic973uN++svs2SefcBjGFGDGiFNWZgavP30uAIsqCgDY32TjTjOG5uYTvaDt22H//v7xiowMWL7cic611/YL0GmnucFywzAmjBkjTkGKcrOoLMrhgIlT+ujpgcOH3SC86sAlcV0q+4zkuGgU9uwZ6Ak1NPTblpcHK1fC+efD3/99vwitWOHCTIZhTDozUpwAFpUXsL/Z0snHjfZ2ePppePJJt2zYMDAsNhmUljrRufrqfgFavdqNC2VmTq5thmEMyYwVp6WVRTy56/hkmzF9aWyEp57qF6OaGue1ZGW5iYm33OLEIDPTjcn4iz+4P9J1IzkuI8MJ0Ny5Nh5kGNOUGStOp80t5n831tPcFaa8MGeyzZn6HDrUL0RPPunCZeBCZBdcAJ/+NLz61S5UVlAwubYahjHtmbHitHJuMQA7jrZz4fLKSbZmiqEKe/fCE0/0i9GePW5bcTFcdBG8851OjF7+chunMQxj3Jmx4nRatSdORzpMnFRd0kDQMzp0yG2rqHAi9KEPuZ9r1rjQnWEYRhqZsXeZ2UW5VBTmsPNox2SbMvHEYlBb2y9ETz3lxpAA5s1zIvTqV8PFF7s0aqshZhjGBDNjxUlEWDm3mB1H2yfblPQTDsPzz/eL0bp10OGJ8rJlcM01/YK0bJklERiGMenMWHECOG1uCfc+s4+LvvBn7v2H81g++yTr7/SXv8B//7cTo1DIrVu9Gt7xDidEr3qVq3xgGIYxxZjR4nTVmXOprW/lhf0tPPXS8ZNHnPbtg49/HB54ABYuhJtvdmJ00UWu3I5hGMYUZ0YPJqxdUs4DN19AZVEuWw6fBOG9ri649VY3v+h3v4Pbb3d14776VVeY1ITJMIwhEJErRGSniNSJyCcH2b5IRB4XkRdFZJOIXJUuW2a05wRu7On0eSVsOdQ22aaMHlX4+c/hX//VZdm9/e3w+c87r8kwDCMFRCQTuBO4HKgHNojIQ6q6LbDbp4D7VfXbIrIaeBhYkg57ZrTn5HPG/BLqGjoJRWKTbcrIeeEFF657xztcRYR16+CnPzVhMgxjpJwH1KnqHlUNA/cB1yXso4BfBbkUOJwuY0ycgDPmlRLtU146No3Syo8ede0bzj3XtXf4wQ/guefgla+cbMsMw5iaZInI84HlpoTt84GDgff13rogtwF/JyL1OK/pQ2kzNl0nnk6cPs/1dNpyqJ01C8om2ZphCIfhG99w40mhEHzsY/CpT1lLB8MwhiOqqmuH2D7YHBJNeH8DcI+qfllELgB+LCJnqGrfuFnpYeIELCzPpyAnk7qGzsk2JTmqLsnhlltg1y43N+krX3FtHgzDMMZOPRAcD1jAiWG79wBXAKjqMyKSB1QCDYwzFtbDJUUsKi/gQPMU7e+0fTtceSW84Q2uyvcjj8BvfmPCZBjGeLIBWCEiS0UkB7geeChhnwPAawFEZBWQB6SlvYOJk8fC8gIOTjVxammBj3wEzjwTnn0WvvY12LQJrrhisi0zDOMkQ1WjwAeBR4HtuKy8rSJyu4hc6+32UeAfRaQW+Dlwo6omhv7GBQvreSwqL2DdrkZUFZns8j2xGNx1lxtLamqCm26Cz37W5ikZhpFWVPVhXKJDcN2tgdfbgAnJujLPyWNReQE9kRjH2ntp6QpPniFPPOHaUNx8sys1tHEjfOc7JkyGYcwoTJw8FpW7Bnnv/+kLXPj5P7P9yARXjNi/H972NrjkEhfOu/9+Vxvv7LMn1g7DMIwpgImTx0JPnDYeaKUnEuN9P35hYibl+iWHTjsNfvtblyK+Ywe89a1WHdwwjBmLiZPHgln58devWz2HA83d7Ehnrye/5NBpp7nxpDe9ydXB+/SnIT9/+OMNwzBOYkycPPKyM5lbkkdOVgbvvnAJAI0dvem52AsvuHYVb387VFW5Zn8/+5mVHDIMw/CwbL0Ar1hWTnZmBosrXIivsXOcxenYMfiP/4C773YJDnfdBTfe6OYuGYZhGHFMnAJ8/fpzAOJjTeMmToklhz76UZcmXlo6Puc3DMM4yUhbWE9EFnp9P7aLyFYR+edB9hER+YbXO2STiLwsXfaMhLzsTIpzs2jsHKeU8ne9yzX/e/WrYcsWuOMOEybDMIwhSKfnFAU+qqobRaQYeEFE/pjQG+RKYIW3vAL4tvdz0qkszuX4eHhOqvDoo/Dud8M994z9fIZhGDOAtHlOqnpEVTd6rztw5TASy69fB/xIHc8CZSJSnS6bRsLsotzxSYg4cABaW+EVU0JzDcMwpgUTkq0nIkuAc4C/JmxKpX/IpFBZnDM+Y041Ne6nTaY1DMNImbSLk4gUAf8LfERVE8supNI/BBG5yW+QFY1G02HmCVQW5Y7PmFNtrZtMe+aZYz+XYRjGDCGt4iQi2Thh+qmq/mqQXVLpH4Kqfk9V16rq2qysiUkwrCzKpa0nQjg6xh5aNTVwyilQVDQ+hhmGYcwA0pmtJ8APgO2q+pUkuz0EvMvL2jsfaFPVI+myaSRUFuUC0NQ1xtBeTY2F9AzDMEZIOt2QVwLvBDaLiDfwwr8DiwBU9Tu40uxXAXVAN/D3abRnRFQW5QDQ2BGmunSU5YTa2mDvXnjve8fRMsMwjJOftImTqq5j8DGl4D4KfCBdNoyFymLnOY0pKWLTJvfzrLPGwSLDMIz0IiJXAF8HMoG7VPXzCdu/ClzqvS0AqlS1LB22WIWIJFR54nSwZQzdcS1TzzCMaYKIZAJ3Apfj8gE2iMhDwbmpqvovgf0/hMvCTgtW+DUJ88vyWVpZyO82jWEIrLYWKith3rzxM8wwDCM9nAfUqeoeVQ0D9+HmoibjBlyr9rRg4pQEEeHNL5vPX/c2c7B5lN5TTY0L6VlfJsMwJp8sf0qOt9yUsD3leacishhYCvw5PaaaOA3JG89xv5dfv3ho5AdHo66OnoX0DMOYGkT9KTne8r2E7SnNO/W4HnhAVdPWkdXEaQgWzCpgzYJS1u9uHPnBO3dCb6+Jk2EY04WU5p16XE8aQ3pg4jQs5ywsY1N9G7G+ZA8QSfCTISxTzzCM6cEGYIWILBWRHJwAPZS4k4isBGYBz6TTGBOnYTh7URnd4RgvHRthy/baWsjJcW3YDcMwpjiqGgU+CDyKK9R9v6puFZHbReTawK43APd5U4HShqWSD8M5C2cBUHOwlVXVJakfWFMDZ5wB2dlpsswwDGN8UdWHccURgutuTXh/20TYYp7TMCyuKGBWQTYvHmhJ/SDV/kw9wzAMY8SYOA2DiHD2wjJqD7alftDRo3D8uCVDGIZhjBITpxQ4fV4pdcc7CUVSzJq0ZAjDMIwxYeKUAquqS4j1KXUNnakdYOJkGIYxJkycUmBVdTEA244k9kpMQm0tLFkCZWmph2gYhnHSY+KUAosrCsnPzmR7quJkyRCGYRhjwsQpBTIzhJVzi9l2OAVx6uqCl16yZAjDMIwxYOKUIquqS9h+pJ1h551t2eJSyU2cDMMwRo2JU4q8bFEZ7aEof93bPPSOlgxhGIYxZkycUuSaNfMoL8zh+0/uGXrH2looKXEJEYZhGMaoMHFKkfycTN55/mIe29HA7uNDpJTX1LiQnvVwMgzDGDUmTiPgLS9fAMD6uiQtNPr6YNMmC+kZhmGMEROnEbBgVj4VhTnU1rtSRodbe3hq1/H+HXbvdtl6lgxhGIYxJqwq+QgQEc5aWEbtwVYALr7jcSIxZd/nr3Y7+MkQJk6GYRhjwjynEbJmgauz19kbJRJzaeXx9PKaGsjMhNWrJ9FCwzCM6Y+J0wg5a2EZqgPHnXqjfe5FbS2sWgV5eZNknWEYxugRkStEZKeI1InIJ5Ps8zYR2SYiW0XkZ+myxcJ6I+SsBa5e3vcCKeU94Rh52ZnOc7rkkkmyzDAMY/SISCZwJ3A5UA9sEJGHVHVbYJ8VwL8Br1TVFhGpSpc95jmNkPLCHC5dOZvn9/c3H+yJxKCxEQ4dsvEmwzCmK+cBdaq6R1XDwH3AdQn7/CNwp6q2AKhqQ7KTeWI3akycRsGnr1lNdmb/PKaeSMyF9MDEyTCMqUqWiDwfWG5K2D4fOBh4X++tC3IqcKqIPC0iz4rIFUNcr05E7hCRUQ3CW1hvFCybXcSX3noWz+xu4r4NB+kJx6xskWEYU52oqq4dYvtglQMSi4lmASuAS4AFwFMicoaqtg5y7BrgeuAuEckA7gbuU9WU2juY5zRKrjt7PlevqQY8z6mmBubNg9mzJ9kywzCMUVEPLAy8XwAcHmSfB1U1oqp7gZ04sToBVe1Q1e+r6oXAvwKfAY6IyL0icspwxpg4jYH8bBdS7Ql7YT0L6RmGMX3ZAKwQkaUikoPzeh5K2Of/gEsBRKQSF+YbtOCoiGSKyLUi8mvg68CXgWXAb4CHhzPGwnpjIM8Tp97OLti+Ha65ZpItMgzDGB2qGhWRDwKPApnA3aq6VURuB55X1Ye8ba8TkW1ADPi4qjYlOeUu4HHgDlVdH1j/gIi8ejh7TJzGQH6OE6fsnTsgGjXPyTCMaY2qPkyCV6OqtwZeK3CLtwzHGlUdtEq2qn54uIMtrDcG/LBe/rYtboWJk2EYhs+dIlLmvxGRWSJyd6oHmziNAV+cindshYICWL58ki0yDMOYMqwJZvF5c6POSfVgE6cx4If1SndtgzVrXF09wzAMAyBDRGb5b0SknBEMJdmY0xjIzcpAUCrqtsM73zHZ5hiGYUwlvgysF5EHvPdvBf471YOHFScRKQR6VLVPRE4FTgMeUdXIaKw9mRARlnc3kdfVYZNvDcMwAqjqj0TkBVzquQB/E6zTNxyphPWeBPJEZD7wGPD3wD2jsPWkZE3jPgDev7WPZ3Yny6g0DMOYeajqVuB+4EGgU0QWpXpsKuIkqtoN/A3wTVV9EzBsrSQRuVtEGkRkS5Ltl4hIm4jUeMutg+031VndsJc+ER7PnsPGAy3DH2AYhjED8Cbg7gL2Ak8A+4BHUj0+JXESkQuAdwC/89alMlZ1DzBUUUCAp1T1bG+5PYVzTjlOO7abA+Xz6cnJo6E9NNnmGIZhTBU+C5wPvKSqS4HXAk+nenAq4vQRXP+OX3uzhZfhZv0Oiao+CTSnash05ZQju9kyeykAR02cDMMwfCJe9YgMEclQ1ceBlCeDDusBqeoTOJcMr7JsYyqze1PkAhGpxRUX/JgXn5w+tLYyt+kI206/HIBj7b2TbJBhGMaUoVVEinB5Cz8VkQYgmurBw3pOIvIzESnxsva2ATtF5OOjNrefjcBiVT0L+CauoGAyG27ye5BEoyl/tvSzaRMA26qc52RhPcMwjDjXAd3AvwC/B3YDb0j14FTCequ9/htvxNVcWgS8c+R2DkRV2/26S149p2yvyu1g+35PVdeq6tqsrCk0NctrMLitahkADR299PUltj8xDMOYWXhdcB9U1T5Vjarqvar6jSGKxJ5AKuKULSLZOHF60JvfNOY7sIjMFRHxXp/n2TK9crFraugsLqOhqByAaJ/S3B2eZKMMwzAmF1WNAd0iUjrac6TihnwXlwJYCzwpIouBYTsZisjPcd0SK0WkHtdoKhtAVb8DvAX4JxGJAj3A9V7F2+lDTQ1Hlp4G0t9A8lh7iMqi3Ek0yjAMY0oQAjaLyB+BLn9lqjkLMho9EJEsVZ2UwZ/CwkLt6uoafsd0E4lAcTHrr7qBt5/6FuaX5XOotYcf3ngul55WNdnWGYZhDEBEulW1cAKv9+7B1qvqvakcn0r5olKc1+M3h3oCuB1oS9HGk5OdO6G3l5ZTVgGwqrqEQ609lk5uGMa0RUSuwHWtzQTuUtXPJ2y/EbgDOOSt+paq3jXYuVIVoWSkMuZ0N9ABvM1b2oEfjuWiJwVeMkTbytMBWFVdDLiwnmEYxnTDS2K4E7gSVwXoBhEZrBrQLwLFEwYVJu98e0VkT+KSqj2pjDktV9U3B97/p4jUpHqBk5aaGsjNpWfZKbCrjqqSPCqLcjjc2jPZlhmGYYyG84A6Vd0DICL34dLBUy7WmsDawOs8XFXy8lQPTsVz6hGRi/w3IvJKXALDzKamBk4/nbyCPAAqC3NYVV3ClkPD5ooYhmFMReYDBwPv6711ibxZRDaJyAMisjDZyVS1KbAcUtWvAa9J1ZhUxOmfcO1294nIfuBbwM2pXuCkRNWF9c4+O94Nt7wwh3MWzWLH0XZ+v+UIb/vOM4QisUk21DAMI06WX8zAW25K2C6DHJOYMfcbYImqrgH+BCQdVxKRlwWWtSJyM1CcsrHD7aCqNcBZIlLivTfX4MgROH4czj6bZbOLKM7LYunsQrojMfoU/uPXW2jqCvPC/hZeecqg84oNwzAmmqiqrh1iez0Q9IQW4ErLxUmYRPt94AtDnO/LwWvjqpO/LTVThxAnEbklyXrfyK+kepGTjhpvyO2sszh7YRmbb3s9ANkLnCPa1OUm4q6razRxMgxjurABWCEiS3HZeNcDbw/uICLVqnrEe3stsD3ZyVT10rEYM1RYr3iYZebiZeoldr+dVZjDsko3jWB+WT7rdjVOtGWGYRijwpu7+kHgUZzo3O91orhdRK71dvuwiGz1CnZ/GLgx2flE5H9EpCzwfpaI/Feq9oxqEu5kMiUm4f7t38Jzz8HevSds+tKjO9l+pJ01C8r42mMvsfFTlzOrMGcSjDQMw+hnEibhvqiq5ySs26iqL0vl+FQSIoxEamrg7MHbknzs9Sv5wY3nctGKClRhvbVuNwxjZpIpIvFabiKSD6Rc283EaaR0dcGuXUnFyeesBWUU5Waxrs5Ce4ZhzEh+AjwmIu8RkX8A/sgQ2X2JTKH+E9OEzZtdKnnCeFMiWZkZnL+sgnV1xyfIMMMwjKmDqn5RRDYBl+HS1D+rqo+menwqtfVygTcDS4L7q+rtI7b2ZMDP1BvGcwK46JQK/rT9GAeaullUUZBmwwzDMKYOXtbfX1T19977fBFZoqr7Ujk+lbDeg7gSFlFc2XN/mZnU1kJpKSxePOyuF62YDWChPcMwZiK/BPoC72PeupRIJay3QFWvGKlVJy01NS6kJ4NNph7I8tkVAR+3AAAgAElEQVSFzC3JY13dcd7+ikUTYJxhGMaUIUtV491XVTUsIimnLqfiOa0XkTNHZdrJRizmxpxSCOmBm7B80YpK1u9uImbt2w3DmFkcD8yPQkSuA1IOI6UiThcBL4jITq/Y32ZvkGvmsXu3y9ZLUZwALjqlktbuCFsPz+z2V4ZhzDhuBv5dRA6IyEHgE8D7Uj04lbDelaO17KQjULYoVfzyRevqGlmzoGyYvQ3DME4OVHU3cL6IFOEKPnSM5PihauuVeEVeR3TCk5raWsjKgtWD9d8anNnFuZw6p4gNe5vhkvSZZhiGMdUQkauB04G8QF3WlDK9h/KcfgZcA7yAK5sezABQYNlojJ3W1NTAqlWQlzeiwxbOKuBIm3XINQxj5iAi3wEKgEuBu4C3AM+lenzSMSdVvcb7uVRVl3k//WXmCRP0Z+qNkMqiXJq6etNgkGEYxpTlQlV9F9Ciqv8JXMDAlhxDklKFCBGZBazAtdoFQFWfHKGh05vjx+Hw4RElQ/hUFOXQ1Bmmr0/JyBg+Bd0wDOMkwO+Y3i0i84AmYGmqB6dSIeK9wD/jGk/VAOcDzzCCdrsnBUnaZKRCRVEu0T6lPRShrMAqlBuGMSP4rdcy4w5gI2446PupHpxKKvk/A+cC+73mUecAM69g3Cgy9Xwqi5wgNXaGh9nTMAzj5EBVP6uqrar6v8Bi4DRVvTXV41MRp5CqhsDV2VPVHcDK0Zk7jamthfnzYfbsER9aWeSqxDd22riTYRgzD1XtVdURTfZMRZzqPdfs/4A/isiDJPSVnxGMMhkC3JgTQJN5ToZhTGFE5Aqv4EKdiHxyiP3eIiIqImvTZcuwY06q+ibv5W0i8jhQCvw+XQZNSUIh2L4drr12+H0HoaLQeU6WsWcYxlRFRDKBO4HLgXpgg4g8pKrbEvYrxrVo/2s67RnScxKRDBHZ4r9X1SdU9aFgMb8ZwbZtrq7eKDL1AMoLcxCB+pYe7nvuAB2hyDgbaBiGMWbOA+pUdY93j78P15Eikc8CXwSGnLwpIo+lsi4ZQ4qTqvYBtSIys0tqjyEZAiAzQygvyOHe9fv45K82c8XXnuJAU/c4GmgYhjEsWSLyfGC5KWH7fOBg4H29ty6OiJwDLFTV3ya7iIjkiUg5UCkis0Sk3FuWAPNSNjaFfaqBrSLyHIE+Tqo6uhjXdKS2FgoLYfnyUZ+ioiiHpq4wc0pyOdTaw4M1h/jQa1eMo5GGYRhDElXVocaIBpuEGW+nICIZwFeBG4e5zvuAj+CE6IXAedtxYcOUSEWc/jPVk5201NTAmjWQmTnqU7hxp06uPKOax3c2sO1I+/jZZxiGMXbqGVjBYQEDk9+KgTOAv3h18uYCD4nItar6vL+Tqn4d+LqIfEhVvzlaY1LJ1rvKG2uKL8BVo73gtEPVeU6jDOn5VBa7pIhXn1rJ6uoStps4GYYxtdgArBCRpV5TwOuBh/yNqtqmqpWqukRVlwDPAgOEKYGjXvIEIvIpEfmViLwsVWNSEafLB1k3c9po7N8PbW2jTobwqS7NIzcrg/OXVbCquoT9zd109kZ5bm8z7/vx80RjfcOfxDAMI02oahT4IPAosB24X1W3isjtwaaBI+DTqtohIhcBrwfuBb6d6sFDtcz4J+D9wLKE5oLFwNOjMHR64idDjFGcbr54OdeeNY+CnCxWVZegCjuPtvP1x17i6bomjnX0Mr8sfxwMNgzDGB2q+jDwcMK6Qas6qOolw5wu5v28Gvi2qj4oIrelastwLTMeAT4HBCdjdahqc6oXmPbU1IAInHHGmE5TXphDeaGbjLuquhiARzYf5em6JgCOmzgZhnFycUhEvgtcBnxBRHJJLVoHDCFOXqmJNuCGMZs4namthVNPddl648T8snxK87O5++m98XXHO2yCrmEYJxVvA64AvqSqrSJSDXw81YNTVrEZyxjKFiVDRPjW28/hrS9fyI0XLgFMnAzDOLlQ1W6gAbjIWxUFdqV6fEr9nGYsra2wbx/clDhXbey8asVsXrViNpFYH/es32fiZBjGSYWIfAZYiysU/kMgG/gJ8MpUjk+b5yQid4tIQ7D8UcJ2EZFveAUGN40kxXDC2OTlgYwxGWIosjMzKC/M4XintXE3DOOk4k3AtXjFG1T1MC6hLiXSGda7BxdvTMaVuO66K4CbGEGK4YQxxrJFqTK7KNc8J8MwTjbCqqp4VSZEZEQD92kTJ6+N+1BZfdcBP1LHs0CZN2A2daipcf2bqtNr1uxiEyfDME467vey9cpE5B+BPwF3pXrwZI45JSsyeGRyzBmE2loX0pPBSk6NH7OLc3l+vytbuL+piwwRFpYXpPWahmEY6URVvyQil+Nq6q0EblXVP6Z6/GRm6w1ZZHDAjiI3+ZV0o9Foms3yiERgy5a0h/Sg33NSVW65v5b33vs8zhs2DMOYnojIF1T1j6r6cVX9mKr+UUS+kOrxkylOwxUZjKOq31PVtaq6Nitrgpy9nTshHE5rMoTP7KJcQpE+OnujHGzuZuexDl7Y30JvNMaHf/4iWw+n3t14y6E2jrT1pNFawzCMlBhT6bvJFKeHgHd5WXvnA22qOnVCeuNUtigVZntFYY+0hTje6caefvrXA2zc38pDtYf5/CM7Tjjmnqf3sutYxwnrb/7JC3ztjylPJTAMwxhXROSfRGQzsNLLxPaXvcCm4Y73SZsbIiI/By7BNZyqBz6Dy3NHVb+Dq990FVAHdAN/ny5bRkVNDeTmwsqVab+UL05bD7ehCqX52Ty8+QhzS/MAeGpXI5vr2zhzQSkAPeEYt/1mG5etquKud5874FyNnb00dlpyxXSkqzdKb7QvXubKMKYp41L6Lm3ipKpDlj3yUgw/kK7rj5naWldPbwLCiH5Nvef2ut/bDect4jtP7Obe9ftYVF5Ac1eYnz23n88tWANAQ4ebE/X4zuM0tIeoKnEi1huNEYr00dZjbeCnI597ZDubD7Xz4AdSmqNoGFOS8Sp9Z+WLBkPVeU4TENIDWDArn5zMjHgR2GvWVFNRmEN3OMZFKypZPa+El451xvdv8NLOY33Kr148FF/vi1J7yMRpOnK0rZfj7TYZ2zDAxGlwDh+GxsYJydQDyMrMYEllAQeauwHnSV2+eg4AaxfPYvnsQvYc7xenY94NrCg3i6d2HY+vb/fEyTyn6UkoEiMUtb5ehgEmToNTW+t+TpDnBLB8dhEAOVkZlBVk87ZzF7JgVj4XnVLJssoiWrojtHSFATjW7jynFXOK6Aj1p9a3mThNa7rDUXojseF3NIw0ISJXiMhOr6zcJwfZfrOIbBaRGhFZJyKr02WLidNg+Jl6a9ZM2CV9caouzUNEeNmiWaz7xGuoKslj2WxX9WNPo/OeGtpD5GRlsGBWwaDiFIr00Ru1m9x0oyfSZ56TMWmISCZwJy7dezVwwyDi8zNVPVNVzwa+CHwlXfaYOA1GTQ0sXQqlpRN2yeVVToDmeMkNQZZ5wrX7uKsi0dDRS1VxLsV5WQPEqb3nRKEyRs7h1smZJxaKxIj1KdGYCZQxKZwH1KnqHlUNA/fhyszFUdX2wNtCkhROGA9MnAbDL1s0gQQ9p0QWzsonO1PY2+jE6Vh7iDkleRTnZtERSH4IClK7idOoqGvo5MLP/zmeOTmRdIfdw4V5T0aayPIr7XhLYi+gZCXlBiAiHxCR3TjP6cPpMtbEKZHOTti1a8KSIXx872juIOKUlZnBovKCeFLEsfYQVcW5FOVm0RvtI+zdzILiZJ7T6DjQ7B4A9jZ2DrPn+NMTdqFYG3cy0kTUr7TjLd9L2J5SSTlVvVNVlwOfAD6VDkPBxOlENm92qeQT7DkV5WZx59tfxrsuWDLo9uWzi+Lp5A3tvc5zynNzsDp73RN3MnH6yh928vstU6f4xlSmqdMlnUxUlfiOUIRL7nicp+saCUXcQ4Z5TsYkkXJJOY/7gDemyxgTp0QmIVPP5+o11fEJuYmsXTKLvY1d7G3soqM3SlVJLkV52QB0hpKLU0tXmG/8uY6bf7KRnzy7P82fYPrT3DWx4rTxQCv7mrrZVN9G2BtrMs/JmCQ2ACtEZKmI5ADX48rMxRGRFYG3VzOCtusjxcQpkZoaKCuDRYsm25IBXLi8EoBfe5Nuq4r7Paf2UIT9TV209USo8kohtXU7cdrjjVMV5mRy99N7J9rsaUdcnCaoBFTNgVZ3vYAY+h6UYUwkqhoFPgg8CmwH7lfVrSJyu4hc6+32QRHZKiI1wC3Au9Nlz2T2c5qa1Na68aY093AaKaurS5hVkM09nsAsn10YH6P47aYjfPfJ3VQU5rK4ooCGjl7avMw9P4niyjOreeCFelq6wsyaxNptDe0h9jZ28YplFZNmw1A0jaPndMP3nuXcJbO45XXJ6zO+eLDFXS8ghjYNYHqiqjy5q5G1i2dRmDs9b62q+jCu7mlw3a2B1/88UbaY5xQkFoNNmyYlpDccGRnChcsraQ9FufKMuZyzaBZFnue05ZArGNvY2Ut5YQ6FOZnxsN6+xi4yM4Trzp4H9N8MW7rCA3pGqSqPbT9GrG98MkMPNnez5dCJrT6+++Qe3nPv8+NyjXQwnmG9XQ2dbDtyYuV4H1Xlxbjn1F+2yDyn6cnTdU28++7neMM313GgqXuyzZn2mDgFqauD7u4Jz9RLlWvWVLNgVj63XXs6AMXemFOwtFFJXjal+dlxcdrb2MWi8gJevngWmRnCxv2t3PXUHs757B/53eb+JIn1u5t4z73Ps66uccx2dvVGedUXH+eab647Ydvh1h46e6P0jZMIjjfj6Tn1RmI0dyU/z97GrvjvKXg985xO5KHawzxYc2j4HSeRP+9oICcrg/3N3fx8w4HJNmfaMz19z3QxickQqXDlmdVceWZ1/H2RFzo43Nb/1F2an01JQJz2NHaxtLKQgpwsVlUX88On99LlhQP3B57uXjzgPKrGcbgpf/H3J/af8vHrAvZG+8jPyRzztUZKdziKIEmv7YtJVzhGV290TOGZnkiMlu7kKf1+9mVuVka8mC+Y5zQYd6/bS3c4ynVnnzDtZsrwl50NXLCsgpqDrXT3TlDH7pMY85yC1NS4Fhmr01YualzxEyKClOY7z+lP24/xiQc2sa+xiyUVrvrEBcsq6I7E+MClyxHpT0EHqDnoQnDjMT/qwVqXfSrCCR6SXxewZ5Iy0j5yXw0ff6A26fbmzjCl+c4jHUtfrEisj2ifxsOEg+FPup1Tkjeg0od5TifSHoqwt7FrylbP2NfYxZ7GLi5dOZv87Ex7wBgHTJyC1NTAqlWuyeA0IDcrg+xMl7hRWeRsLs3PIifL/Vp/8fxBeiIxlnq1+W65fCVPfvxSPv760ygvyIkLkapSc9CNfbSOUZw6e6O0dkeYXZyLKnQEBLCvT+O9qEKTJE71LT3x6u+JhCIxusIxVs4tBsYW2vM/X1tPJOkN1Rdov9mkT6/d2E6gvSdKJKZJf3fjyW83HWajF0lIlad3u3D4xSuryMvOmLSHr5MJE6cgk1C2aCyISHzc6bJVVfzjq5by2lVz+PerVvGNG87hzre/jOLcLM5ZWAZAfk4mC8sLAAaMSx1pC8W9hLGWPTrU4urSnT6vBOhPaQdo6Q4TiTlParL+ebvD0aSf0fdyThsXceoXmGSC72dbzi5KECfznE7AL9NV15C8cseBpu4BST6j5b9+u50frBvZtIudRzsozs1iSUUBedmZk/bwdTJh4uTT0OD6OE0jcYL+cafq0nz+4+rVLCwvYFV1CdeeNY+r11RT+5nXccb8EwvYluRnx2/SvtcEYw/r1be4J1tfnFp7+sNafkgP+m/ME01XODYghBbEF6e45zSGsF7w5tSSJLQXSuI5WUhoIKFIjF6vakbd8cHFadexDl59x+Os39005uu19oST/o20dUfYVN96wvpdxzpZXlWEiDhxsiofY8bEycdPhpiimXrJ8MUp8Qbnk5Ex+HytsoJ+z+l3m49QkpfFqXOKaO1OPkaSCodafc/JCWJrwHM6FujyOlneQU84RnsoMugTtp+pt6KqmAwZW3JIUJySjTv1RGJkZcgJ887McxpIUCh2N3QNus/OYy5lf8fR5Kn7qRCKxAhF+gYUVA7ytcde4vrvPXvC30/d8U5WVLn6mHnZGYQm6eHrZMLEyWeaipOfFFGVRJyS4Yf1GtpDPLrlKG9bu5DZxblj9pwOtfSQk5XBKd4/avB8QXHqCU/8k6Wq0hV2Yxe9gzzZ+pl6lUU5FOVm0Z7k6TkVelIQp+5wjPzsTIoTMgLNcxpIUCiSeU4Hm3u8n2Mbk/KjCclCvxv3t9AdjsVLTQG0doc53tHLijnubz4/O5OQPWCMGRMnn5oamD8fKisn25IRERenktGJ08+fO0i0T3nH+Yvj61q6wjyy+QhPvnSccLSP//zNVvY2dvH7LUe466k9Q563vqWH+WX5lBW4sbDWAeIUTJee+H/eUKQP/4F3sJuPX/S1ojB3QNhztNfyaU7ijYYiMfJyMuOTqcEluZjnNBD/IWFheT57kow5HfTCyWNNmPAfpgYL64UiMbYdce2Munv7f0f+ONiKKhcOzsvOnLSw9cmEzXPyqamZduNN0D8Rt6r4xFYbQ1Hq3Xw37GvmjPklLK0spDTfZfC9/6cbeWZPExkCH3v9Sn749D5ifcq6XY3Ut/Rw/XmL4uHEROpbnTj56dgtXWEerDnEVWdWcyxQBWEyEiK6woHGjKEoVSUDtzd3hcnKEErysyjOy6Y9SWgnFXpSGHPq8Twn/7vMycqgIGdsaci/2ljPLzYc5Bfvu2DU5xhPQpEYedljm8/me06nVhXz2I4G970lzFPzPaaxek6tQ4jT9iPt8YSernA0Ho71xemUeFjPPKfxwDwngFAIduyYluJUlJuFiAtFjYTS/Gz6FHYcbWdRQgbfS8c6eNWKSjJEuOPRnQD8auMh9jR2EY718cTO44AbG0mMvR9q6WbBrHxyszIpyMnk0a1H+ef7anhq13GOtYUo8byEyRCn4NPuYMLT7NUdFBFK8sYW1hs45pQkWy/iiZP3neRnZ5KblTkmz2lTfRvP7Wsel6y1sXKwuZu1//UnvvyHnWM6j9/heUmlmxLRNEjVDT9L9EBz6hl7t/9mG0/tOj5gnT9G2hOJEUmYAhBMHOoOeEa7GjrJz86MdxTIs3lO44KJE8DWra6u3jQbbwJ4/elz+cdXLSMrc2S/ypL4RNMwC2Y5cSoryCYSU5q6wly4vJKr11SjCmfML4lP2C3OzeIP245ysLmbCz73Z+5Zvy9+zlAkRmNnOP5PWpqfzXYvDHK8o5fjnb0sqiiI7/v9J/dMWGsKgO5Iv9h0hKK0dod59RcfZ90uN0elqStMhfc0HAzr1bd088GfbYxPmgWXtvzVP76U9EY4IFsvSVivJ9JHXk7/mFNBTqYbTB/Djc09MDDomNpEc/fTe+nsjfLNP9fxh61HR30e/0EiLk6dA7/Pvj6lvqWHYq/5Zip/U6rK3U/v5Z0/eG7APLTgGGlnwsNJbUCcugLz91480MJp1cXx5KNkCRHtociYwtk7j3bQNEHV8qcCJk4w5csWDcVFKyr596tWjfg4P+wGsGBW/gnrFlcU8KHXrOC1p1XxrRteRlaGcPbCMq44Yy5/2naMf7hnA81dYV7Y3z9Z8fdb3A3IT133vTNw3kNTZ5gFZU6cdjd08t8Pb+fXL9YPsKuuoTNtT/1dQc+pJ8Iftx3jQHM3NV4x3OauMOWeOBXnZcVDO798vp7fbjrCzqMdfOyXtdy7fh8PvHCQrz+2i8NtIdbtajzhhujfhCqLcpMmRITCMfKzM8bVc/KFbbLHPNp6Ity/4SBXn1nNGfNL+OSvNo/6QcQP6y31Kp0kfp8NHb2EY328Ylk50D/+NBR+eA7gN5v6++kFs1UTQ3t7G7vI90KU/t9SRyhCbX0br1zeP1adLCHinT94js8/kry013C84Vvr+N6TQ4/5nkyYOIEbbyoshOXLJ9uSCSMVcTqlqogf3HguSyoL+c/rTudfr1jJ+y5ezilzitnb2EVVcW483q6qfPsvu1lRVcTFp84GiCdFgMuEa+zsZb53raNe5l5wAPulYx1c9pUneGbP2OeqDEb3gDGnCI9uPQYQr2sXFKeSwJjTX15yoZ+2ngiPbT/GbzcdZpf3uQ+19HDjD5/jrnUDbxq+OMwvyxvCcxo45pSXfaLn9LmHt/OFIWoVJuKL4mRXKHh2TxNd4RjvvnAJX33b2XT2Rrn9t9tGda72nigZ4hIioD/l38cXows8gUglKSL4APDAC/0PSMEkmMTQb3N3OP6/4o9fbtjXTKxPuXB5fwuYvOxMIjE9oTLIkdaeUY+JhSIxwtG+eMRjJmDiBE6c1qyBjJnzdQwUJy+sN0CcCgfs/45XLObC5ZWcUlXEgx94JTv/60reeM589nj1zp7d08zOYx3cfPHyeHijLL9/HKy+pYfeaB9VxbnkZPYXOj3gpQCDq1QBJ1YBUFV+/My+MYc0gp7Tsfbe+HiDn+Le1NnbH9bLy6KzN0pjZ2980mVbT4S2ngg7jnTwkjevpvZgK9E+pT7wOaC/1fq8svwTwlA+PRE3sF+c6773gpwTPadn9jTx1xGI9VQRJz88Vl2ax4o5xVxzZjXP7R3dQ0d7KEJJfjYVXiWNxL8D/4Z/gdcjbM/xwedCBQmGPYOhvNahxKkzHB+f9R90nq5rIicrg5ctnhXfLy/b3UcSJ+KGIrERJdn8/LkD3PbQ1gG2lAxST3M8EZErRGSniNSJyCcH2X6LiGwTkU0i8piILE6XLTPnbpwM1WlXtmg8CHo1/hiR/1RWUZiTNBvPJzNDOKWqiHC0j4MtPRxodjeE8wNPkMFr+J5GRVEuudkZNHhp5Qea+m8kfvjGH9z22XaknU8/uDXeBXi0BD2nP2w9Sm+0j6LcLBo6eonE+mgPRSkvdDfAkvxsVOGRzUfi6eeHW0P0efUCd3s3QL8/lj/52Mf3nKpL82npDhOKxPjcw9sH3Ahdtl5Wf1gvJ5PcBM+pJxwbMPg+HL4oTXZYzx+vKfGySSuKckY9h64jFKU4L4vCnExyszJOCOv54r+wPJ9XLC3nf1+oH7ZAbFCcgg8tQRuDYT2/7qJf/ss/5tk9TaxdPGtARqIf+kscXwpF++LJHalw7/p9/Oy5A0RjfXFb0uk5iUgmcCdwJbAauEFEEqtgvwisVdU1wAPAF9Nlj4nTvn3Q3j7jxMn3nMoLc+JtIfx1i72kheHwU2frGjrjGWnlBf3ekn++rAxhn9eRt6Iwh/zszHgB2PqWnniDQ/8ftz7hRu835Ns/xgZuwZu8X0ngolMqaWjvjad7lxf1h/UAnnjpePxJeLBwkd9m/XBroucUIycrg4qiHLrDMZ7d08R3n9zDX3Y29O8TiZGfk0FmhnjJEL7n1H/j7A7HRuQFxcecJtlz8m+mhbnuRl1WkEMo0jeqhID2nggledmICBWFOTQmeKIdoQgiUJiTxXtftYzDbSEe2TJ0AkavZ0d+duaA5IbW7kj8oSooTr4g+mE9/0Fnf1N3vNyVT64nTsEHhFifEo72pew5NXX2suNoB+FoH/uauuPhRv/vMk2cB9Sp6h5VDQP3AdcFd1DVx1XV/0d4FliQLmNMnGpq3M9pmKk3FvKzM8nOlPg/G/R7OokhvWT44rSroYOW7jB52RkD5p+Ueuc7fX4pUU+AKopy4jF5gGifcqTN3djbEzynmoOtfOeJ3fEK0WOdYOnfUPwK7ovKC1hSWUhDRyh+w6sIJEQAbD/SwZKKQnKzMgYdL/B7aTV09A4Ix4W8OUz+GNYur3fTkbaBc738p+yi3CzyvTGn3sANvCfiPKd9jV28+dvrk86Zil93qnhOvRHyszPjWaT+E/9oJjb7nhO4h4fEBo7toShFuVlkZAivPa2KReUFA8aRBsN/ACgvzBkoTj2ReOguWJmiX5wKvM/nQnSdvVGqSwfOMfS9qODfg/86Wc2+RJ7d0xx/vfNoR3xaQ0n+mMJ6WSLyfGC5KWH7fOBg4H29ty4Z7wEeGYtBQ2HiVFvrxprOPHOyLZlQRITS/Jx4SA/cDbKqOJezFpxYKHYwSvKymVOS63lOYWYVDJxrdfWZ1XzkshXxqujgwnr5CZMyfdHxb1x+iOz7T+7h84/s4A9e4sJYJ1j6oZg5XjWNU+cUU1WcSySm7Gl04lEeSCX3bZlXlk9JfvYAcRTpr17uc7RtYKv1vOyM+Heyq8F5ar6HpaoDxOkjl53K9ectHMRzitITjlFb38oL+1uo8ca/mrvCg7YC94+dbM+pszc6oN+Y70WPJrTXHor0hwcLc2nqCtPVG41ndXb2RuPp+BkZwqrq4vgDTzKC4tQdicX7jrX3ROIPbEEh8ZMwKotyKMjJpLs3Gv99zy3ND546/jsNlujyPdrO3mhKPanW726kMCeTDIGdR9vHy3OKqurawPK9hO2DFeIcNHVWRP4OWAvcMRaDhsLEqaYGTj0VClILZZ1MfPqaVbzv4v4MRRHhyX+9lHddsCTlcyytLGRfYxet3SeK0+KKQj5y2alxbwScZ5KXZHa/7zkd7+glFInx3D739NjZGyUvO2NACHA4nq5rPCGxojscJT87M36jXDm3iDkl7qnXn4+V6DkBzCvLozQ/Oy4sq6tLWFFVFG/i6BMcd/KFxxc7v+utf47eqCul5H8Xb3/FIi5cXuk8J+8pu69PCUX66A5H4/PM/PDovz5Qy3t/tOGEz+17TpPdsqE9FB1QlslPthlJv7AjbT28+dvr2XG0Y8B46N7GLs797z/xu81HAOfhFAdu2hVFuUmTUHx873RWYQ6q/WLe2h2motA9QA30nJy3Vl6YQ0FOFl3hWNwLPtFz8hMiAp504PfRmUKX3Of3tXDu0nKWVBSy81hHf0JEerP16oGFgfcLgMOJO4nIZcB/ANeqatomXpk41VVD8GAAACAASURBVNTMuJCez3Vnz+fsgFcDLiSRrJL5YMwrzedYe++ANOxE/DIvhd64Sp7XDHFOSS5ZGRIfSwoOFj+7p4njHb3x9OHLV88lHOsbUDw2GarK+3+6kf/3eN2A9V3hGIW5mfGnz5VzS+I1CXcccZ5NMJXcZ35ZASV5WfHQ5NeuP5ufvOcVcQ9smdfM8XBr0HNyZXvKC915fKE81Dqw2WKiF5mb1V9dwL+59Wl/CaT9Td10hCI8+VLjgOsFrwuMKIkiHXSGogMEI+45DdG2PpH7N9TH59H1aX9YuCMUpTsci4dKg2E/gMrCHJq7w0M+yPiek/8w0hWO0tentPVEKM3Ppjgva8DfY7DuYmFuJt3hKEc97yxRnAZLiAh6sqkkRRzv7GV+WT4r5xa7sJ53zGDdr8eRDcAKEVkqIjnA9cBDwR1E5BzguzhhahjkHOPGzBan1lbYv3/GJUOMJ3NK8zjWHqLJK/0zGP4NwE828MelZhXkcEpVEU97PXiCg8X/52XmffOGl/HFN6/hrS93466J405f+P2OAROBwXkwbT2REwqu9oRjFORkxf/BV3phPXAJEiJu4B4GPqH6npPPgln5VJXkUeV5XS9f5NKIf/n8Qf75vhd58UALPZ44+d6k/7Tse049ycQp4DkFBcafwLq3sYvHdx4nHOujszd6YkbYBE/Cbezs5RcbDpywPhhqg/7xzFTDeqrKr1+s5+yFZVy+eg5vWDMPIJ5NCf3z0zoSvLSKIteFOdn8MhgY1gMX8u0MR+lT4uLU0TtwzMmvu1iQk0VXb4zDrSFETqxrmTdIQkTw9zRcUoSq0u6J5Mq5xexv7uZYe4isDDnh72U8UdUo8EHgUWA7cL+qbhWR20XkWm+3O4Ai4JciUiMiDyU53ZiZ2YVfp3FliKlCdWke0T7lYHM3l3iTbxPxRavCu7H4/2Al+dlcdcZcbvvNNl480EJ7T4TFFQXsb+rm0a3HKCvIZs38Us5eWBYfXznQ3M353nyW7nCUb/9lN/sau3j54pfHr7ftsAvRtSQ8pXf1RinIyaSiKJecrAyWVhbGn64PtfZQXphDpuc1Bp9Q53tjTgDZmf03CD8kuKSykMqiXP6614Uhf7fpCLOLc1lcUUBpfjYixNPR23rcILp/40osYJqX5ZJFYn064ObmNz7c19TFo4FSQE1d/eWiVDXubQ015hSN9XHjDzdw6pxibn1DYqbwyPi/Fw/xX7/bzqWnVQ24SXeEIgM6/JaOMKy38UAr+5q6uePSU3jr2v5IUzBE7At2Z280XtoInHcFztupLBq8Wr//ANAvTtF4GG/+LPf7fnjzUa755lPc/74LBtRdLIp7TiEqvb+lIIPNcwpODxhOnHoiMaJ9Skl+NtWleahXA7Mk32UsphNVfRh4OGHdrYHXl6XVgAAz23OaoZl648lc7wbdpyT1nPwbgF+c1n+yLMnL5i1rF1Kcm8U96/fREYpy6pxicrMy6InEuO6sefEQY3VZHpkZMiAJwJ8r9XRd44AQznYvRNeW8OTcHY5RmJvFe1+1lPtuOp+cLJdd6AuR370XIDszIy5C8wJV1kvzc+I3CD+sV12ax6LyfGYVZPOdv3u5l4EYimer+cfmejexI609cfFIrNid693YeqMDU8j9G3F9Sw9/3t4QDyUFJ6T641gw9JjTHX/Yybq6Ru5+emStyAfD94QSs/A6E0JtxXlOpJN5Tn19yuce3s5+b97brzbWk5edwZVnVg/Y77TqYoq8dui+YLsxp4Dn5D0EDVYg1qc3kug5ReOh3VXVJfGyW1sOtVNzoJWmrnB8moTznKIcaQ+dENKD/t9p8HfQO4Kwnv8dleZnxx88th/pSPsE3KnGzPq0idTWQlUVzJ072ZZMW6oDmUpJx5y8f2p/e1yc8rMoys3i8tPn8ORLjWRmuCfjX73/QnKzMlg+uyh+juzMDBbMyh+Q5OCHddpDUX5Te5jC3CwuXz0nntzgP6X39Sm/2XSY1h6XtFFZlDvgifrGC5cQjvXxodesGGB3cV4W4Vgfc0ry4mNQpYFU3jXzy3jNaVVcsLyCNV6G4+z/396ZR7ddXXn8e7XvkvfdTuI4TuIQJw4JgUAINAmkC0xhCmlnaCl0KF2GtlNOB6al0D86pWXaKczplKXllA6dQgu0k05haENZSlma3VlsspHFjpd4l2xZsuQ3f7zf++knWZKVxLJk6X3O8bEs/SS9p5/87u/ed+/3OiKLlZhnoc2EobEJLK10Yc+pIXQO+dXFNDZMY1c8KZ+yryIQxik8yeCfDONr6xvxrd8dwpEeHx7YdhDfv2lFVI1Zoj2n8CTDT//MjZLo3BoP8Zld01SetOWFapxiUqS9gehQm15HcJoNUy4YBB2Dfjz2xnHYTAbcuWEB/re1C9c0lU8pBl9e7cH+Bzbj7l+34u1jfep7a0OIxRrPKREirCe+m6PBENq6R2A16lFXaINXY0R3nRyM2lO1m/XoHApjLOhX9xu1xDNO/nMI6wnj5bIYUakYp2ElqpBPSM+puZnnBUvOizJ3ZJH32BIZJyOMelLDYFaN5wQA9SUO9Pl4UoXLakRTpRsLS51TQhjN1R7sOT2ophD3avpDffnZvfjc07sQCIXR1s2N07B/ApOTDDtODOBLz+zFgc4R2ExTF9qvbm7EvVuWTFkIXVYjyl3cY4t4TppNfpsRT966GhVuKxaWOrGw1Am3zageI+YpFrXmap58cmZoXE0zjg3ribTkziF/lKLFWW9A/ZouLnfiqsZSAMD2th7sPjWEPx7qjsoOSxTWGxwLqokdo0myxsRn9uPXjiU8BojfnG9ykk3ZcwL49yOR53TWx8/l8T4fXm3vxbB/Aje0xK/vJCKUOM046+O1ZcHQZLTnlEDmSIsI64kQ4GggjLauETSWc3XxRz6+Eo/+/SosKnNg1ynFODkinpNIJa+ISSMH4idEaMN609U6aT2nUqdZDTWnuQA360ircUpBp+lWIjqrbKztJaLPpHM8UUxM8FYZcr/pgii284w7IFodQotBr8PTt1+CT6+bDyASkxf7OEISZiLMpixoWlpqPegZCagpvCKsV19ih454QW9rxzBO9o+hUEkR9o6Holp7202pBwuKHSb1alUUP7pTSOUVRZxCKUCEO5dWuqDXEbqGI4Yn1nMSNTadQ/6oxW00GEZjmRNWox6fXjcPxUoihyhQ3n1yKHoxTOA5CW+ixGlOmtIstAOffPP9KKXuWEZU4xQxOmMTvG2HM2YxdVuNCfechGd47KwPv9/fjWKHGes0UlixiPq0DqVgW/teHqsROorUJsX2ZQLieE6BENq7vVhSwWvXllW5ce2ycqyqK8Duk4Po80Z0F+0mPbpHxuENhNQLLi2WuHVOkfPR7wtgf8dwwrmpNU1WAwx6nRo6v8AC3DlH2oxTijpNAPAsY2yF8vOTdI1nCu3tQDAojdMFotNFPKICe+KF+5IFRaoHEfGc+D9bXWEkXJGsjkOIa4oFudcbgEmvw6/vvEzt/PqrHbzAfd1CrlA9OBaMEgINpVgnBQDfu7EZ371xuTJWPq5E3qEW0bPKqgnrATyBotxlQWeSPSeh2t456J8SmqvyWLHjGxtx8+paVWeuRzHQu08NRmvyJfCc+hRvoq7QhtHg1GaRgsM9PpgMOngDITyz43TcYwDtnlPE0AldPUfMHoloZjkZ5xwI43T87Ch2nRjA2gWFSXuUlSjGWZxbrder0xEK7Sa8dawfl37nFSz6xktRSSTA1D2n432jGBqbwOLy6PbIK2sLMDIegi8YUtX2bWaDuicVW4gN8BCmUU/RdU6a2z976wSu/9GbCVupDMcU3Kral9JzmjGm1WnKKDIZYsYoVzaFE+05xSJCWcIQ1UYZp8RXh0sqXLAYddh9kqsk9I6Mo8RpRqHdhBU1Hhj1pPbmuXoxX0iG/BNRfXgOdCa+Yo2ltsimenXxwnoJn6c8R3iIBZqEkEqPBWc0XlFsWM9lMcJlMaAjjnGymw3qIkxEUftmvd4A3u+LeIjTGafaIhvCkyxhU8LDPV4sq3ShxGnG+0lUvofjeE7idmxNjttmxJ5TQ2i6/2XsORWd/i+M01gwjDPD42ipLUAyhHE6pnjFse9VZDdj18lBHg7F1PMeCIVh1JP6PFGOEGtsrlxUgsYyJ35wUzM+sKQMQGRfEECUGrkW3g1XE2ZVzqXTbMBYMIxJFq0ookXsSYnvWqVHeE7SOM0Uqeo03ajIrz9HRDVxHk8P+/YBZjPQ2Dhrb5mrCOMUqxCRCHPMnpPHZlQXiWRXh0a9DsurPKoSeK83oC5SRj1PoBifmMSiMgdqC/lG9dBYEMfP+nDV4hJc21SO+69rOo8ZRhaGVBYI4QkKgyg26EucZlR6rMqeU/w6J4Drt8WG9QCoAr0CsV8iQoFvH4u0pEiUECHCenXK55MotHe014eGUifKXOaovb1YRCKEdh/Fq7xm7B6eWGz9E2G8pYx17+kh/McrR9TMO8GqBIu+QNSnCcMZG0IUn82l9UUoc1mmFCwHQpMwG/Qw6nUwGXRoV5Jo5hdHJziUuSx4+Svr8dGVkf0vcR7KXZaEFyuxxklcBJS4IhcUibIJYwtuRVJEspB3LpJO45SKTtPvAMxT5Ne3A3gq7gsR3SHECkOh1CXnk7J3L9fTM+TXCU8HDaUOlLnMSbO6tFg12XoA9wKEtzHd4t9Q5lAlfHq94+oiBUBVh15VV6AWfZ71BnB60I/6EgcevWWVGpo5V87Pc+LzvKGlGg9vXYFSpwWVHiu6hv0YTWKcqgqsccN6DnP0sWIPZMuychh0hF2KN+KyGBKmkvePBqDXkRo+jJcU0e8LoH80iIYyB8qcFjV0qGUsGEIwNKnJ1pvaaiLWm9Eaq4NnuCfz7I5T+P4fD+PY2VF1PmaDDksqosNrsahhvb4EnpPiVW5cUoYKt2WK1l4gFFZT++0mPUaDXEU+UV2UFrOBn4ellYnHaDXqo8Ks4xNhEEXXafUlSNgY9k/AYTaoYc3KmJY2+UI6jdO0Ok2MsX6NNtMTAFYhDoyxx4VYoWEmjAljeS1bNNPceWU9fn/XFSkfLxZZbTNC1ThNE1evcFswODYBfzCMXm9AlR8CuJArALTUFqhabvs7hxGeZFOuiM+VSo8Vn7l8PjYpoZ1kzFfSi7VtSa5fUaW+Dt/I5/VaZsPUf8HqAis6BsdU4ySy9KZ6Tnzu9SUOFDvMOK00PCywm1TP7IFtB7HhoVfxtef2gTGGfh9PiRaGIp7nJHQAF5U5UeqyxPWcbn7sHdy/7SCCikeg9Zx8qnGKPpe9ivSU1ajHgU7uqZzo45/DnlODaKpyw27SY3m1e0phaywOswEWo07tqzU1rMe/Wx9YUooKjzVKDR7ge06qcVI+i2qPNSXpLtHFeWkSA2ox6qYoRFgM+qiLmz5vZM/pQOcwHnudZ0ZyodvoInAg/xIi0jlbVacJQCe4TtMntAcQUQVjrEv58zpwyYz0c+YM0N8vkyFmCN5ePHVZlQ2Npfi3jzWrmVFAJIlgun9Akbp7coBvYGtVCS5fWIwn33wf6xYWq4uASJ5YUJK4picV9DrCNz6cmppChduKZ+5Yq6aOa6lUQqCtHcNqm4dYqjxWjAbD6B72w2LUQUfEC4hN8cN6tUU2FDtN6oLvsZnQ7wuAMYZf7TwNh9mAX+3swNoFRejzBVDsMKvGSdtoTyCyGxcqHnGfL4h3j/fjL8f68ZWNDWCMt3GI3Wdq7RhCXaEdPkX2Jzas98WrG+CxmVBgM+Hftx/GsH9CLbqdCDOUOs348sZFUWoPiSAiVLqtON4XP6y3dU0N5hXZUF1gQ6Xbgu2HesAYU8sTAqFJNbwsPtfqwtTqiG5eXYPWjiHcdvn8hMdYjPopqf0WI1cluajKjfe6vejThPWefuckntlxGltX12LYPxHlJS1V9v4ay5J7k7lG2owTYyxEREKnSQ/gSaHTBGAnY2wbgLsUzaYQgAEAt6ZrPFGIZAhpnDKCxajH366KrmFZ31CCd48PqNX9iajwRBZ3AFFhveYaD3bdt0n922k2oK2La+bFK5ZMJ0JiKRYRojl4ZiRhiFH0DDrS64PNZICOIuoWWoQ80Lwie9TnVmAzomNgDH2+IMaCYdy9uRG/az2Df32xDcUOM0qcZrUJYLyw3qn+UZgNPIVZZGL+cPsRvH28HxsaS1BbaEMwzJvgCfpHg/jYo2/j9svnq4kxsdl6C0sdeOC6Jrx++CwA7i2d0Xg0JU4z/mH9grifSTzWLypRjVOsIVxc7lIz7yrcVgRCkxgcm1DHFhXWUz4LbW+zZFR5rPjZp9ckPYarmms76U7CatTj3i1LEJpk2PDQq1Gek+gU3a60x9AapzKXBTu+PmuqQVlDWuucGGMvMsYWMcbqGWPfVu77pmKYwBi7lzHWxBhrZoxdxRhrT+d4VIRxWr58Vt5OMj3rFhbjt19YN204p1LxnHYq7TTK4sjHCNw2I8KTDC21BVmThlup6Z91RUNx3GPEInmkxwerUa9m9Nlj9pxubKnGIx9fiUqPNWqvpNBmgn8ijFMDfOGeV2zDXVc3oM8XRHu3F0WasJ43jnE6PeBHdYFVKRPgr7vzJP+8n3rrxJQsM7NBhyM9PgRCk3i/b1RdlB0JasqETNSL+7ui7i9JYb9Hy+amSIg12fdGZLtpuxWPxwvrpWicUqGx3Im2rhFVVkuo1Ot0pHRINqt7TowxVfmkvdurKqPnO/mpELFvH7BgAeDKLzc5FxCZgX9q51ffyeL+Invw6sWl6R9YirgskXRwUYsViyj89QVCsJr0sBn58bHeQYHdhOuauVp3sTOyf+dRjJNoRVJbaMclCwphUjbYixxmdUGO6zkNjKl7gCJsOhFmMBt0eHF/15S07KoCq7p31THoR693HEV2U8L9m2KHGQuK7di2j29BC2NV4jw347RmXmFKx4lQcPfwOCbCkzjS41U8p5iwXsHMyQO11BZgLBhWi5nHJyJhRIBncIpsvbO+gJpY0t49Au94KGsupjJJfhqnvXtlSG+OYjHqUWQ3qXsnpUkWNJGxtzGFJIbZgohQ6bGg2GGOW8AJ8P2TYlUqR+s5JY7Ca72OApsRjPFQERH3CGwmA1rq+B5YkcOU0DgxxhXmhXHSKiB8fE0tJsIMLx2ILmit0SzqpwfHcKx3NEoXMR7XLCtXs9k2L+XaludqnAx6HTYuKUX9NCFbIc7aNezHsztOY8vDf0bvSEAV2U2H57Syln/WYs9zXNlzEhQ7zOjzBvGdl9rw9Du85YjFqENbl1cJ6+VX8kM88s84+XzA0aMyU28OI/adLqpyJW0hUF1gQ32JHYvKLiwZYqa5ZW0dvrSxIenY65Quu1ajXtUDjPWctIiwnlFP6l7P4W4vyl0WNVnlioYS9VhVYDbGOA37J+ANhNTi4yJNG5HrV3Av7e3j/VHPqdIs6kNjEzh4ZnjaPb4ty7hBcluNuKGlCusXlSRNzU7EE5+8GK98dUPSY4odZhj1hDPD4zjUNYLQJMOpgbHz3nNKhdpCG4rsJuw5xQvGx5XOyIIihxndI+N47PXjeOSVIwCADywuw6GuEXgDIRnWQz4ap/37eSq59JzmLCJMs6zKnfS4+z68BM9/7rK098A5V265dB5uWVuX9BgR2rOZIsYpmeckjJPFoFcXwfZur2pkAJ5WrdcR6kscMOh1sBh1GA2EEApP4sGX2nGyf1RNRxfP0+kIpU7es+iiKjdPhghNosJtUfd5Yhf10WB4Ws/poio3qjxWzCu2o6bQhp/ftua8QlmpnFudjlDhtuLUwBiOKXs7oUmmhvWqC6wocZrPec9runGtrPVEPKdQOCqjVXjGAqfFgCsXlaip+akWtOcy+ec7StmiOY9Ix26qTG6cbCYD5ur/+HzhOZn00Ouir/DjIfaczJoEis4hPy7TiKcuLndh932b1Ktyh9kAXyCMv54YwKOvH4PZoFNrxbShunI3D0Ma9DosLnfi1MAYKj1WWE16dA+Pq9qBhXaTqhc3nedExJW/UygrmhGaKl3Y3zEcJeskwnq3rZuPrWtqZ/wiZt3CYmxv68UeRfdQG9YTIcx5RZG9vWuayvFejxdFDpPqpc42RHQtgIfBM6x/whh7MObx9QB+CGA5gK2MsefSNZb8M0779gEeD1Bbm+mRSM4TcVV/UXVy4zSXqSsWYT2DqvqeSljPYozug1UbU7ujDRfZzbxp3vZDvQCAQ10jqmGrKYx4Q/d/pEmVe1lc4cIfDvWg3G2Bw2zAWCCs1hhdWl+E37fyDLzpPCdgeomimaS5xjNlr0x4Tga9Dq4kIrPny8cursEPtx/Bf752DP4gL8IViNT/qxeX4fYreL2U22bEfSnW0qUDjVj3JnARhR1EtI0xdkhz2Cnwkp+70z2e/DNOIhkiy0I9ktS5aXUN6ksdauV8LjJPE9bT6whE8aWOBAU2E3TEE0aWVbnxwucvw8/fOjGlk6wWu9LRVWgVtnWNoNjBhXS1Ra0raiLFxEuUJI4KlwVrVxTh9OCYunnfXO3Gq+29mAhPzuj+zUwQryA6njrHTOIwG3DrZfPwsLKnZNEIxi4qc6DEacZ1Kyqz6XusinUDABEJsW7VODHGTiiPxVcMnkHyyziFw0BrK3DHHZkeieQCcFmMarO9XKVOE9a7ZH4hRsYnkoad9EqbCBE6aqktmFbZ22E2YM/pIQyMBlFXZMPJ/jH8qb0HFyXZyxOad5UeKzYu5VmQ73XzdOmGUieqC6xgDEnbXWSCi6rdIOLbzQYd8T0nY/rHeGNLdcQ4aTyn0swU1hqIaKfm78cZY49r/o4n1n3JrIwsDvllnI4eBfx+mQwhyXrcViPuvLIem5aWYVVdgdquIRnFDnPUAjgddrMeA6NBEAGf31CPf35+P3pGAvinTeUJnzOv2I4ffaIFl2sKiBvLnXjh85dhZY1HbX2RbTjMBjSUOvB+3ygay5040DmihvXSSW2RTdFK9EftOWWIEGPs4iSPpyLWPWvkl3GSskWSOcQ9Wxaf0/Efaa5U075TQWT/ra4rxAbFE9XrCJuWJjZOAPCh5VNDhcJLu2n17HW9OVc2Ly1Ha+cwTHqdYpxmx1hcMr8IHYMdMGaZNxmHacW6Z5P8M04GA7BkSaZHIpHMOF+4auE5HS9kiD60vAKlTrNaGJxq08i5xt3X8N5t977QCiD9e06CVXUFeH53h9oYMYuZVqx7Nskv47RvH7B0KW8yKJHkOSJes2VZOYgIT3xyVUr9jOY6Yo7mc1DSvxA2NPLi5zXzU5NbyhSpiHUT0WoAvwFQAOAjRPQtxtj5dfCchvwyTnv3Aps2TX+cRJIHPLx1Bdq6vChVJIpWTpNAkSuoxmmWPKdKjxUHvnVNVHv3bIUx9iKAF2Pu+6bm9g7wcF/ayR/j1NsLdHXJ4luJRKG6wDajYqdzBVEAO1vGCUheoyaJT9bv0M0Y+/bx3zIZQiLJa2bbc5KcH/lzdmw24LrrpOckkeQ5zTVufHb9AlxaH79liSQ7IMYylsZ+XtjtdjY6OprpYUgkEsmcgojGGGOz2xL6Asgfz0kikUgkcwZpnCQSiUSSdUjjJJFIJJKsQxoniUQikWQd0jhJJBKJJOuQxkkikUgkWYc0ThKJRCLJOqRxkkgkEknWMeeKcJX2wP7zfLoBQGgGhzNXyMd5yznnB3LOqWNljM0Zh2TOGacLgYh2TtMJMifJx3nLOecHcs65y5yxohKJRCLJH6RxkkgkEknWkW/G6fFMDyBD5OO85ZzzAznnHCWv9pwkEolEMjfIN89JIpFIJHMAaZwkEolEknXkjXEiomuJ6D0iOkpE92R6POmCiE4Q0X4i2ktEO5X7Conoj0R0RPldkOlxXghE9CQR9RLRAc19cedInEeU895KRC2ZG/n5k2DODxBRp3Ku9xLRBzWP3avM+T0iuiYzo74wiKiGiF4lojYiOkhEX1Luz9lznWTOOX2u48IYy/kfAHoAxwAsAGACsA/A0kyPK01zPQGgOOa+7wG4R7l9D4DvZnqcFzjH9QBaAByYbo4APgjgJQAEYC2AdzM9/hmc8wMA7o5z7FLlO24GMF/57uszPYfzmHMFgBblthPAYWVuOXuuk8w5p891vJ988ZzWADjKGDvOGAsCeAbA9Rke02xyPYCnlNtPAfibDI7lgmGMvQFgIObuRHO8HsDPGecdAB4iqpidkc4cCeaciOsBPMMYCzDG3gdwFPx/YE7BGOtijO1WbnsBtAGoQg6f6yRzTkROnOt45ItxqgJwWvN3B5Kf8LkMA/AHItpFRHco95UxxroA/uUHUJqx0aWPRHPM9XP/RSWE9aQmXJtzcyaieQBWAngXeXKuY+YM5Mm5FuSLcaI49+VqDv06xlgLgC0AvkBE6zM9oAyTy+f+xwDqAawA0AXg+8r9OTVnInIAeB7AlxljI8kOjXPfnJx3nDnnxbnWki/GqQNAjebvagBnMjSWtMIYO6P87gXwG3AXv0eEN5TfvZkbYdpINMecPfeMsR7GWJgxNgngCUTCOTkzZyIygi/Sv2CMvaDcndPnOt6c8+Fcx5IvxmkHgAYimk9EJgBbAWzL8JhmHCKyE5FT3AawGcAB8Ll+SjnsUwD+JzMjTCuJ5rgNwCeVTK61AIZFSGiuE7Of8lHwcw3wOW8lIjMRzQfQAOCvsz2+C4WICMBPAbQxxn6geShnz3WiOef6uY5LpjMyZusHPJPnMHg2y9czPZ40zXEBeObOPgAHxTwBFAF4BcAR5Xdhpsd6gfP8JXhoYwL8yvH2RHMED3v8SDnv+wFcnOnxz+Cc/0uZUyv4IlWhOf7rypzfA7Al0+M/zzlfDh6iagWwV/n5YC6f6yRzzulzHe9HyhdJJBKJJOvIl7CeRCKRSOYQ0jhJJBKJJOuQxkkikUgkWYc0ThKJRCLJOqRxkkgkEknWIY2TytD7UAAAAh1JREFUJG8horeU3/OI6BMz/Nr/Eu+9JBJJashUckneQ0QbwBWfP3wOz9EzxsJJHvcxxhwzMT6JJB+RnpMkbyEin3LzQQBXKH1yvkJEeiJ6iIh2KEKbn1WO36D02vlv8IJIENFvFZHdg0Jol4geBGBVXu8X2vdS1AseIqIDxPtu3ax57deI6DkiaieiXyhqARJJXmLI9AAkkizgHmg8J8XIDDPGVhORGcBfiOgPyrFrACxjvD0BANzGGBsgIiuAHUT0PGPsHiL6ImNsRZz3ugFcvLMZQLHynDeUx1YCaALXRvsLgHUA3pz56Uok2Y/0nCSSqWwG12jbC96uoAhcswwA/qoxTABwFxHtA/AOuABnA5JzOYBfMi7i2QPgdQCrNa/dwbi4514A82ZkNhLJHER6ThLJVAjAPzLGXo66k+9Njcb8vRHApYyxMSJ6DYAlhddOREBzOwz5/ynJY6TnJJEAXvCW2IKXAXxOaV0AIlqkqLzH4gYwqBimxeCtwQUT4vkxvAHgZmVfqwS8/XpuqEhLJDOIvDKTSLjSc0gJz/0MwMPgIbXdSlLCWcRvbf9/AO4kolZwReh3NI89DqCViHYzxv5Oc/9vAFwKrhzPAHyNMdatGDeJRKIgU8klEolEknXIsJ5EIpFIsg5pnCQSiUSSdUjjJJFIJJKsQxoniUQikWQd0jhJJBKJJOuQxkkikUgkWYc0ThKJRCLJOv4fGNmrKbhfO9EAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faf53f49bd0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 以上是用了全一点的神经网络，下面我们看看不全的神经网络会怎么样\n",
    "# 指定自定制的训练网络路径\n",
    "train_net_path = 'mnist/custom_auto_train.prototxt'\n",
    "# 指定自定制的测试网络路径\n",
    "test_net_path = 'mnist/custom_auto_test.prototxt'\n",
    "# 指定solver的存储路径\n",
    "solver_config_path = 'mnist/custom_auto_solver.prototxt'\n",
    "\n",
    "\n",
    "### define net\n",
    "# 自定制神经网络\n",
    "def custom_net(lmdb, batch_size):\n",
    "    # define your own net!\n",
    "    # 创建一个神经网络\n",
    "    n = caffe.NetSpec()\n",
    "\n",
    "    # keep this data layer for all networks\n",
    "    # 指定数据输入层\n",
    "    n.data, n.label = L.Data(batch_size=batch_size, backend=P.Data.LMDB, source=lmdb,\n",
    "                             transform_param=dict(scale=1. / 255), ntop=2)\n",
    "\n",
    "    # EDIT HERE to try different networks\n",
    "    # this single layer defines a simple linear classifier\n",
    "    # (in particular this defines a multiway logistic regression)\n",
    "    # 指定score的全连接层（也就是说直接用多层感知机，而不用卷积神经网络）\n",
    "    n.score = L.InnerProduct(n.data, num_output=10, weight_filler=dict(type='xavier'))\n",
    "\n",
    "    # EDIT HERE this is the LeNet variant we have already tried\n",
    "    # n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, weight_filler=dict(type='xavier'))\n",
    "    # n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n",
    "    # n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, weight_filler=dict(type='xavier'))\n",
    "    # n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)\n",
    "    # n.fc1 =   L.InnerProduct(n.pool2, num_output=500, weight_filler=dict(type='xavier'))\n",
    "    # EDIT HERE consider L.ELU or L.Sigmoid for the nonlinearity\n",
    "    # n.relu1 = L.ReLU(n.fc1, in_place=True)\n",
    "    # n.score =   L.InnerProduct(n.fc1, num_output=10, weight_filler=dict(type='xavier'))\n",
    "\n",
    "    # keep this loss layer for all networks\n",
    "    # 指定损失loss，用于神经网络优化\n",
    "    n.loss = L.SoftmaxWithLoss(n.score, n.label)\n",
    "    # 返回神经网络\n",
    "    return n.to_proto()\n",
    "\n",
    "# 保存神经网络\n",
    "with open(train_net_path, 'w') as f:\n",
    "    f.write(str(custom_net('mnist/mnist_train_lmdb', 64)))\n",
    "with open(test_net_path, 'w') as f:\n",
    "    f.write(str(custom_net('mnist/mnist_test_lmdb', 100)))\n",
    "\n",
    "### define solver\n",
    "from caffe.proto import caffe_pb2\n",
    "\n",
    "# 指定自定制的solver的训练参数\n",
    "s = caffe_pb2.SolverParameter()\n",
    "\n",
    "# Set a seed for reproducible experiments:\n",
    "# this controls for randomization in training.\n",
    "s.random_seed = 0xCAFFE\n",
    "\n",
    "# Specify locations of the train and (maybe) test networks.\n",
    "s.train_net = train_net_path\n",
    "s.test_net.append(test_net_path)\n",
    "s.test_interval = 500  # Test after every 500 training iterations.\n",
    "s.test_iter.append(100)  # Test on 100 batches each time we test.\n",
    "\n",
    "s.max_iter = 10000  # no. of times to update the net (training iterations)\n",
    "\n",
    "# EDIT HERE to try different solvers\n",
    "# solver types include \"SGD\", \"Adam\", and \"Nesterov\" among others.\n",
    "# 指定SGD随机梯度下降优化器\n",
    "s.type = \"SGD\"\n",
    "\n",
    "# Set the initial learning rate for SGD.\n",
    "s.base_lr = 0.01  # EDIT HERE to try different learning rates\n",
    "# Set momentum to accelerate learning by\n",
    "# taking weighted average of current and previous updates.\n",
    "s.momentum = 0.9\n",
    "# Set weight decay to regularize and prevent overfitting\n",
    "s.weight_decay = 5e-4\n",
    "\n",
    "# Set `lr_policy` to define how the learning rate changes during training.\n",
    "# This is the same policy as our default LeNet.\n",
    "s.lr_policy = 'inv'\n",
    "s.gamma = 0.0001\n",
    "s.power = 0.75\n",
    "# EDIT HERE to try the fixed rate (and compare with adaptive solvers)\n",
    "# `fixed` is the simplest policy that keeps the learning rate constant.\n",
    "# s.lr_policy = 'fixed'\n",
    "\n",
    "# Display the current training loss and accuracy every 1000 iterations.\n",
    "s.display = 1000\n",
    "\n",
    "# Snapshots are files used to store networks we've trained.\n",
    "# We'll snapshot every 5K iterations -- twice during training.\n",
    "s.snapshot = 5000\n",
    "s.snapshot_prefix = 'mnist/custom_net'\n",
    "\n",
    "# Train on the GPU\n",
    "# 最好训练的媒介（没有GPU的话就乖乖用CPU）\n",
    "s.solver_mode = caffe_pb2.SolverParameter.GPU\n",
    "\n",
    "# Write the solver to a temporary file and return its filename.\n",
    "# 保存自定制的solver\n",
    "with open(solver_config_path, 'w') as f:\n",
    "    f.write(str(s))\n",
    "\n",
    "### load the solver and create train and test nets\n",
    "solver = None  # ignore this workaround for lmdb data (can't instantiate two solvers on the same data)\n",
    "# 根据配置获取solver\n",
    "solver = caffe.get_solver(solver_config_path)\n",
    "\n",
    "### solve\n",
    "# 设置迭代次数\n",
    "niter = 250  # EDIT HERE increase to train for longer\n",
    "# 设置测试周期\n",
    "test_interval = niter / 10\n",
    "# losses will also be stored in the log\n",
    "train_loss = np.zeros(niter)\n",
    "test_acc = np.zeros(int(np.ceil(niter / test_interval)))\n",
    "\n",
    "# the main solver loop\n",
    "for it in range(niter):\n",
    "    solver.step(1)  # SGD by Caffe\n",
    "\n",
    "    # store the train loss\n",
    "    train_loss[it] = solver.net.blobs['loss'].data\n",
    "\n",
    "    # run a full test every so often\n",
    "    # (Caffe can also do this for us and write to a log, but we show here\n",
    "    #  how to do it directly in Python, where more complicated things are easier.)\n",
    "    if it % test_interval == 0:\n",
    "        print 'Iteration', it, 'testing...'\n",
    "        correct = 0\n",
    "        for test_it in range(100):\n",
    "            solver.test_nets[0].forward()\n",
    "            correct += sum(solver.test_nets[0].blobs['score'].data.argmax(1)\n",
    "                           == solver.test_nets[0].blobs['label'].data)\n",
    "        test_acc[it // test_interval] = correct / 1e4\n",
    "\n",
    "_, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "ax1.plot(np.arange(niter), train_loss)\n",
    "ax2.plot(test_interval * np.arange(len(test_acc)), test_acc, 'r')\n",
    "ax1.set_xlabel('iteration')\n",
    "ax1.set_ylabel('train loss')\n",
    "ax2.set_ylabel('test accuracy')\n",
    "ax2.set_title('Custom Test Accuracy: {:.2f}'.format(test_acc[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
